Bonjour et bienvenue.
Je souhaite apporter une solution pour le défi tic tac toe.
Maintenant souviens-toi, il y en a beaucoup solutions à un problème donné.
Ce sera juste ma solution.
Si votre solution est différente tant que vous suivez les bonnes
pratiques de programmation et que vous utilisez le langage de programmation c de la
bonne manière, alors c'est très bien.
Je ne fais que fournir ma solution.
Je suis sûr que cela peut être amélioré.
Alors, commençons.
Je vais créer un nouveau projet ça s'appelle évidemment tic-tac-toe, et
nous allons commencez à essayer de le moduler.
J'ai essayé de le décomposer comme je l'ai fait dans la description de la conférence.
Je vais créer un seulement quelques modules ou je devrais
dire quelques fonctions.
Espérons que ce sera d'accord et fonctionne bien pour vous.
J'utilise un étui de chameau pour tous mes noms conventions exactement ce à quoi je suis habitué.
Nous pourrions même séparer ceci en plusieurs fichiers source si
nous le voulions.
Nous avons donc notre principal.
Débarrassons-nous de ce printf.
Je vais inclure un inclure supplémentaire.
Cela me permettra de fondamentalement faire un peu de nettoyage de notre système
et quelques bonnes choses, permettre moi aussi je pense supprimer un char.
Donc en plus de ces 2 bibliothèques, incluons conio. h.
Et ce que je veux faire et je veulent attaquer ce problème.
Je veux essayer de module autant que je peux.
J'ai mentionné que je vais pour utiliser
un tableau unidimensionnel, un tableau bidimensionnel pourrait même fonctionner mieux.
Mais je vais mettre en œuvre ceci
en utilisant un tableau unidimensionnel qui représente notre jeu board, notre planche tic-tac-toe.
Je vais créer ça en tant que variable globale.
J'utilise une variable globale ici parce que
je n'ai pas démontré le concept de passer des données par référence dans c.
Je ne veux pas vous embrouiller.
Je n'aurais pas à utiliser global données ici et
je pourrais transmettre les données aux fonctions, mais je le ferais besoin d'utiliser le passage par référence.
Il faudrait que je passe pointeurs, et nous n'en
avons pas encore discuté.
Je vais donc utiliser des données mondiales.
Pardonnez-moi, mémorisez que les données globales sont généralement pas une bonne chose
à faire mais parce que, encore une fois, nous essayons de démontrer l'apprentissage, diviser la conquête et nous
essayons de démontrer comment utiliser les fonctions, j'ai besoin d'utiliser des données globales parce que
nous je n'ai pas encore parlé de pointeurs.
Donc mes données globales ici que je vais à utiliser est mon carré qui représente
ma grille, ma planche de tic-tac-toe.
Ça va être un single aire dimensionnelle de 10
éléments principalement parce que je ne veut pas utiliser l'élément 0.
Je vais utiliser ce tableau pour choisissez des numéros pour jouer au jeu.
Cela permettra également de moi pour avoir mes coordonnées.
Je vais initialiser ça avec seulement les valeurs 1 à 9.
Et ça va être un tableau de caractères car je dois y
mettre des x et des o.
Nous n'avons pas parlé de caractère tableaux encore, mais cela me permettra de
mettre des caractères uniques.
C'est comme le concept de tableau de ints sauf qu'il contient des caractères.
Personnages, souviens-toi, ont guillemets simples autour d'eux.
Donc un 2 3 9 le, 0 là le o je vais juste sauter, je
ne vais même pas utiliser, parce que je veux utiliser ceux-là.
Cela rend la programmation un peu plus facile.
Je peux utiliser la valeur que l'utilisateur entre en tant qu'index, en tant qu'index valide.
Je vais aussi devoir créer 2 variables globales pour le choix
au tour du joueur.
Donc le choix va être ce qu'ils entrée via le clavier, de un à
9 selon l'endroit ils veulent placer leur x ou o.
Le joueur va juste représente le
tour du joueur, joueur un ou joueur 2.
Je n'ai besoin d'aucune autre donnée globale.
J'ai juste besoin de ma fonction déclarations ici.
Je vais commencer avec la création de 3 fonctions.
Alors je vais en avoir 3 déclarations de fonction.
Je vais en avoir un pour vérifier une victoire.
Cela ne prendra aucune donnée.
Il va retourner un int.
Je vais en avoir un qui ne le fait pas renvoie toutes
les données qui, affiche simplement le tableau avec les caractères corrects.
Cela ne prend pas non plus de données.
Et je vais aussi avoir un fonction qui marque juste le conseil.
Cela prendra l'entrée de l'utilisateur.
Et selon ce qu'ils sont entrés, il placera un x ou un o au bon endroit
dans le tableau, puis affichera ce tableau en utilisant le tableau d'affichage.
Alors ici, nous allons juste dire marquez le tableau et cela va en fait prendre
une marque avec un x ou un o.
Donc je peux réutiliser ça.
Je peux réutiliser ça pour joueur un ou joueur 2.
3 déclarations de fonction pour que je puisse placez mes fonctions n'importe où dans le
programme, je les ai déclarées en haut.
Et vous remarquerez que les 2 de ces les fonctions ne renvoient aucune
donnée et une seule prend un paramètre.
Implémentons ces fonctions avant de mettre en œuvre le jeu.
Alors d'abord, allons mettre en œuvre le chèque pour la victoire.
Cette fonction va essentiellement travailler là où il va vérifier le tableau pour voir
s'il y a une victoire.
Alors ça va contenir beaucoup de déclarations if.
Je pourrais probablement m'améliorer ce code un peu.
Mais je vais mettre quelques commentaires ici parce que nous devrions toujours
avoir des commentaires en haut de notre fonction.
Ceux-ci sont assez simplifiés.
Nous devrions avoir le nom de la fonction.
Cela signifie essentiellement que la fonction va renvoyer
un statut de jeu de un si le jeu est terminé, dites-vous si vous avez gagné,
un résultat négatif si le jeu est en cours et 0 si le jeu est terminé
et que c'était un match nul.
Donc, cette fonction vérifie on renvoie un int.
Alors je vais y aller à venir et définissez-le.
Et tout cela va faire est il va regarder
le tableau et voir s'il y a des taches là-dedans, si 3x correspond.
Donc il y a beaucoup de différentes déclarations if.
Alors, comment savoir si un joueur en est un.
Eh bien, nous savons si un joueur est un s'ils correspondent dans une diagonale de
ligne ou une colonne.
Nous devons donc vérifier chaque une de ces situations.
Et nous connaissons les rangées dans le colonnes basées sur le tableau.
Donc si mon carré est égal au carré 2 et
le carré 2 est égal au carré 3, cela signifie que nous avoir un match dans notre première rangée.
Alors je vais aussi créez une valeur de retour ici.
En haut, je vais juste dire valeur de retour, initialisez-la à 0.
Nous initialiserons ceci à 0 pour la fin de la partie.
Et si nous avons un match dans la première rangée, je
vais en retourner une, la partie est terminée.
Il faut alors avoir une série d'autres ifs pour correspondre et en fait je ne veux
pas revenir celui que je veux définir ma valeur de retour.
Parce que nous pourrions revenir mais ça rend le programme plus difficile à suivre.
Sinon, nous allons vérifiez toutes nos autres lignes.
Alors je vais copier et coller du code ici parce
que c'est beaucoup de code redondant.
La seule chose qui intéressant est si nous avons un tirage au sort.
Alors laissez-moi mettre tout le sinon pour les gagnants.
Et puis je vais aussi renvoie des valeurs différentes.
Au lieu d'avoir un tas d'autres si, je pourrais avoir des esperluettes, mais
c'est encore plus difficile à lire.
Donc si nous avons un match dans la première rangée.
Et assurons-nous que notre l'indentation est correcte.
Si nous avons un match dans notre deuxième rangée, c'est ce que fait le second.
Si nous avons un match dans notre troisième rangée, retourne un ajouter de nouvelles lignes pour la lisibilité,
pas besoin de crochets parce que ce sont des déclarations uniques.
À la ligne 37, il ressemble à nous faisons correspondre un, 4 et 7.
Donc, cela ressemble à un correspondance diagonale, retournez-en une.
Quarante, nous faisons correspondre 2 5 et 8.
Cela ressemble à un match du centre en descendant, donc la deuxième colonne.
3 6, vous pouvez voir le d'autres matchs aussi.
Nous devons essentiellement attraper tous les matchs pour les lignes, les colonnes et les diagonales.
Et c'est ce que nous avons fait de tout ces déclarations à la recherche dans le tableau.
Maintenant, la seule chose qui nous dit si nous nous n'avons pas de match ou nous avons un match nul, c'est
que nous devons tous les comparer et assurez-vous simplement que ce ne sont pas les
nombres qui ont été initialisés.
Donc, si nous avons notre carré de tableau et il ne contient pas 1 2 3 1 2 3 4
5 6 8 ou 9 pour aucun des valeurs, cela signifie que nous avons un tirage car elles
contiennent un 0 ou un x.
Alors pouvons-nous en écrire un autre si cela dit
essentiellement que c'est un tirage au sort et que nous pouvons définir la valeur de retour à 0, valeur de retour égale à 0.
Et encore une fois, c'est juste fondamentalement vérifier ce dernier sinon si, si les
nombres sont les mêmes comme ils ont été initialisés.
S'ils sont tous différents, alors cela signifie que nous pouvons retourner 0.
Mettons-en un.
Sinon, si nous n'avons pas de dessiner et nous n'avons pas de gagnant, cela
signifie que nous n'avons pas terminé.
Donc, une dernière déclaration d'autre peut simplement dire la valeur de retour est égale à une valeur négative.
Parce que rappelez-vous, la fonction est renvoyer un négatif pour le
jeu en cours, un pour le jeu est terminé et 0 pour le jeu sans résultat.
Et puis la dernière chose que je veux faire est je veux renvoyer la valeur de retour.
Alors ici je vais juste dire retour, valeur de retour.
Et cela complètera la fonction.
Et que remarquez-vous quand nous faisons cela, nous
divisons et conquérons.
Tout ce sur quoi nous nous concentrons bien vérifie maintenant le tableau pour voir s'il
y a une victoire.
Nous travaillerions en petit des morceaux comme celui-ci et
nous testerions constamment.
Cela nous permet de nous concentrer sur notre conception et nous permet également de réduire ou
d'isoler nos erreurs plus facilement.
Maintenant que nous en avons terminé avec le plateau de jeu, nous voulons aller de
l'avant et mettre en œuvre le tableau d'affichage.
Le tableau d'affichage est juste va montrer le conseil.
Donc tout ce qu'il faut vraiment faire est dessinez le tableau dans un format spécifique.
Alors nous allons écrire un fonction appelée tableau d'affichage.
Il ne retournera aucune donnée, cela ne prendra aucun paramètre.
La raison pour laquelle c'est un numéro de fonction
la première est que nous allons devoir dessiner le tableau plusieurs fois et c'est juste mieux
parce qu'il fait une tâche spécifique.
Maintenant celui-ci va juste avoir un tas de fonctions printf dedans.
Et ça va avoir un tas de formatage.
Je vais donc le copier et le coller.
La chose qui est unique ici est Je nettoie l'écran à chaque fois.
Mais si vous dites système et Windows et vous dites cls, cela va
effacer l'écran.
Cela le rend juste plus propre.
Nous allons alors simplement faire un tas de printfs.
Nous allons imprimer le titre du jeu. Nous allons imprimer les joueurs 1 et 0.
Et puis nous allons pour imprimer le tableau.
Le conseil va être bien formaté avec des barres parallèles,
puis nous allons imprimer le valeurs de toutes les valeurs du tableau.
Et si la valeur est x ou 0, il va s'afficher.
Si ce n'est pas le cas, il affichera un nombre afin que nous puissions utiliser
ce nombre pour sélectionner notre option pour dessiner et c'est c'est tout ce que fait cette fonction.
Maintenant que nous en avons fini avec en
affichant le tableau, nous voulons maintenant créer notre dernière fonction qui marque le tableau.
Alors le tableau de bord va se fixer le tableau avec une
valeur particulière, et il va taper une marque dans un x ou un o.
Alors ça va prendre un personnage.
Ce que cela va faire est il y
aura un tas d'autres déclarations if.
Alors ici, dans notre tableau des
marques, nous va vouloir faire quelques commentaires et dire que ceci va définir
le tableau avec le caractère correct x ou o au bon endroit dans le tableau.
J'espère que cela a du sens.
Comme vous voyez le code, je je dois terminer mes commentaires.
Je veux le formater gentiment donc c'est 2 lignes ici.
Et tout cela va faire
va-t-il vérifier ce que l'utilisateur a entré.
Alors rappelez-vous, nous avons 2 données globales valeurs pour ce que l'utilisateur a entré.
Nous avons aussi une valeur pour le joueur actuel.
Donc le choix va être fondamentalement ce qui est entré via le clavier.
Nous ne l'avons pas encore implémenté parce que nous allons implémenter
cela dans la fonction principale.
Le joueur va être le joueur actuel.
Nous allons avoir besoin des deux de ceux-ci pour faire nos marques.
Donc ce que nous allons faire, c'est que nous va avoir un
tas de déclarations else, des déclarations if else.
Nous allons vérifier le choix, qui est ce qui est entré par l'utilisateur.
Et si le choix est égal à 1, on veux dessiner quelque chose dans ce carré.
Nous voulons également nous assurer que ce carré est disponible.
Donc, si c'est égal à 1 et que ce n'est pas le cas actuellement égal à 1, cela
signifie que fondamentalement quelqu'un a déjà mis un x ou un o là-bas et nous ne pouvons pas l'utiliser.
Si c'est égal à un et qu'ils entré un, cela signifie que nous pouvons
définir le tableau sur une valeur spécifique.
Nous allons définir le tableau sur quoi a été passé soit dans le o soit dans le x.
Et nous allons répéter pour faire cela pour chaque choix.
S'il s'agit de choix 2 3 4 5 6 8 ou 9.
Donc un tas d'autres ifs qui font la même chose.
Si l'utilisateur a entré le choix 2, nous sommes va s'assurer que l'indentation est
bonne et que le carré 2 est disponible, nous allons marquer la case 2 avec tout ce que nous
avons passé ici.
Et selon le tour du joueur est, nous allons passer dans un ou un x.
Maintenant, la dernière chose que nous devons faire cette fonction est que nous devons valider.
S'ils passaient dans quoi que ce soit autre qu'un à 9,
alors c'est un mouvement invalide.
Donc notre dernière autre déclaration ici imprimera un message disant déménagement invalide, il sera marquez le
joueur en bas.
Parce que souvenez-vous des joueurs sont un ou deux.
Et nous allons marquer le joueur retour et puis nous allons l'incrémenter dans
notre boucle sur notre fonction principale.
Et puis cette dernière chose devient char est juste en train de suspendre le
programme pour que l'utilisateur doive frapper retour après un déplacement invalide.
Sinon, un déplacement invalide s'affichera, puis il serait immédiatement
effacé car nous redessinerions le tableau.
Alors get char le met en pause.
Cela vous oblige à appuyer sur le bouton Entrée pour continuer à entrer une autre valeur.
Et ce sont nos 3 fonctions.
Rappelez-vous, cette fonction ne renvoie rien.
Nous pouvons donc le garder au fond.
Maintenant, nous devons en fait mettre en œuvre le jeu.
Le jeu va dans la fonction principale.
Donc pour le jeu, c'est là que nous allons demander à l'utilisateur d'entrer un nombre,
nous allons dessiner le conseil d'administration, nous allons vérifier la victoire.
Nous allons donc créer 2 variables locales ici, et nous
allons initialiser notre lecteur.
Ici nous allons créer notre entier I.
Cela va être utilisé pour notre boucle.
Et notre marque sera soit x ou o, selon le tour de qui c'est.
Mark va être x ou o je crois.
Mark va être x ou o.
Et le choix va être quoi l'utilisateur entre via le clavier.
Donc 2 variables locales.
Nous allons également définir notre player, qui est une variable globale.
Au départ, ça va juste Soyez le premier joueur pour commencer la partie.
Ensuite, nous allons avoir une boucle.
Nous allons avoir un une boucle jusqu'à ce que nous ayons fini de jouer.
Je vais utiliser un peu de temps boucle ici parce que je veux
qu'il s'exécute au moins une fois.
Je veux afficher le embarquez au moins une fois.
Alors je vais afficher le plateau et jouer au
jeu jusqu'à ce que j'obtienne un match nul ou une victoire.
Alors je vais le faire aussi longtemps comme I est est égal à moins 1.
Que représente un 1 négatif, il représente que le jeu est en cours.
Je vais être le retour valeur pour vérifier la victoire.
Et vous le verrez dans une seconde, mais fondamentalement quand
j'ai une boucle qui continue de faire la même chose et encore jusqu'à ce que le jeu soit terminé.
Et le jeu va être plus si ce n'est pas négatif.
Alors, que devons-nous faire en premier.
La première chose que nous devons faire est nous devons afficher le tableau.
Donc je peux juste appeler le tableau d'affichage des fonctions.
Ensuite, nous devons calculer le joueur.
Et le joueur commence le premier joueur.
Ce que nous allons faire
ici, c'est nous allons utiliser un opérateur ternaire, et nous allons dire si le joueur mod 2,
alors le joueur est égal à 1 sinon est égal à 2.
C'est une façon de déterminer le bon joueur.
À chaque itération de la boucle, ça va pour passer de un à 2 ou de 2 à un.
Quand il commence en tant que joueur un, ça va dire
joueur mod 2, un divisé par 2 ou le reste d'un divisé par 2 est quoi, un.
Alors si c'est un, tu es va être le premier joueur.
Et quand tu reviens pour le l'itération suivante,
le joueur sera égal à 2 car nous allons l'augmenter.
2 mod 2 est 0.
Donc si ce n'est pas égal à un, alors le joueur sera
égal au joueur 2.
Cela ne fera que le régler sur joueur un si le joueur mod 2 en est un.
Souviens-toi, ce tourneur avec un peu de chance.
La prochaine chose que je dois faire est que je besoin d'obtenir l'entrée de l'utilisateur.
Alors ici je vais dire, je vais pour demander à l'utilisateur de saisir un nombre.
Je vais dire joueur percent d soit le joueur 1 ou 2, entrez un nombre, puis je vais mettre le
joueur pour imprimer, joueur un ou 2.
Ensuite, je vais lire le entrée de l'utilisateur à l'aide de scanf.
Et ça va être un entier, cela va représenter une
place sur le tableau un à 9.
Et je vais stocker que dans ma variable de choix.
Le choix est un pouce, alors je faut passer dans l'adresse,
et je dois dire choix.
Seulement si c'est une chaîne je le ferais pas passer dans l'adresse.
Ensuite, je peux essentiellement déterminer si oui ou non quelle est la marque.
Je dois déterminer si la marque est un x ou non basé sur le joueur.
Alors je vais utiliser le opérateur ternaire à nouveau.
Et je vais attribuer pour marquer un x ou un o.
Si le joueur est égal à 1, je vais attribuer pour marquer le x, x majuscule.
Sinon, je vais attribuez-lui un o, majuscule o.
Donc, cet opérateur ternaire est très utile lorsque vous devez affecter
des variables en fonction d'une condition.
Encore une fois, ce que cela dit est si le joueur est égal à
1, la marque sera égale à x.
Sinon, ça va être égal à o.
Le point d'interrogation représente si l'évaluation booléenne est vraie, les deux-points
représentent si elle est fausse.
Maintenant que j'ai la bonne lettre, Je peux appeler ma
fonction pour marquer le tableau en disant simplement marquer planche, passant dans le x ou le o.
Après avoir marqué le tableau et ils fait leur sélection,
je dois vérifier s'il y a un gagnant.
J'ai ma variable I qui devrait
probablement être un meilleur nom.
Appelons-le vérification de l'état, jeu vérifier que diriez-vous de cela ou de l'état du jeu.
Et le statut du jeu va être égal à un moins un ou 0.
Le statut du jeu va être égal à ce qui est
retourné par chèque pour gagner.
Parce que rappelez-vous, cette fonction renvoie un un un 0 ou un un négatif.
Un si le jeu est terminé avec le résultat, négatif un si le jeu est en cours, 0
si c'est fini sans résultat.
Alors maintenant que nous avons stocké le jeu status, nous voudrons également changer
la condition de la boucle.
Donc, si le statut du jeu est égal à moins un, nous allons
sauter hors de la boucle.
Sinon, tout ce que nous devons faire c'est changer le tour du joueur.
Comment changer le tour du joueur, nous incrémentons simplement le joueur de un.
De cette façon, la prochaine fois, ça augmentera et ce sera 2, et le
joueur sera égal à 2 et nous redescendrons.
Quand ils font des tentatives non valides se produit dans les modèles non valides,
il décrémente le nombre de joueurs.
Lorsque vous décrémentez le nombre de joueurs, vous revenez au bon joueur.
Donc si c'est un, vous le décrémentez 0, le prochain tour sera un, c'est essentiellement
le même tour à nouveau.
C'est pourquoi nous l'incrémentons.
Maintenant, si c'est le joueur 2, nous l'incrémentons d'un.
Et ce qui se passe est 2 divisé 2 est 0.
Donc, il définit réellement le joueur de nouveau à un.
Voilà comment ça marche.
Mais c'est toute la logique.
Nous avons beaucoup fait ici.
Tu ne devrais pas tout écrire ce code et testez à la fois.
Vous auriez dû travailler avec la division pour la conquête, en testant constamment pendant
que vous exécutez le code
Maintenant je vais fournir cette solution, mais exécutons-la
et testons-la.
Ça va fonctionner comme ça l'a fait dans la démo de la conférence de défi.
Mais encore une fois, étudiez ce code et faites sûr que vous comprenez ce qui se passe.
L'utilisation de tableaux et la division Conquérir l'approche, mais regardez à quel point
cette méthode principale est belle.
Il est très facile de savoir ce qui continue dans la méthode principale.
Tableau d'affichage, changez de joueur et vous veulent probablement mettre des commentaires ici.
Changez de tour, puis ici aussi obtenir une entrée.
Et puis définissez le bon lettre, définissez le caractère correct en
fonction du tour du joueur.
Tu n'as même pas vraiment besoin ces commentaires parce
que les fonctions sont tellement descriptives.
Marquer le tableau, définir le tableau en fonction de le choix de l'utilisateur ou le choix invalide.
Et puis le contrôle de l'état du jeu pour gagner, assez explicite.
Et puis nous sautons si le jeu est terminé.
Construisons ça.
Avec un peu de chance, n'obtiens aucune erreur, non avertissements, nous ne le faisons pas, ce qui est bien.
Maintenant, exécutons-le et vous allez voyez que cela fonctionne comme dans notre démo.
La première chose qu'il fait est va afficher l'écran.
Et ça va permettre nous pour imprimer une entrée.
Et il a notre grille, une 2 3 4 5 6 7 8 9 notre tableau.
Alors ça me dit le joueur un entrez quelque chose et je
saisis quelque chose de valide.
Et ça le dessine, et cela efface l'écran.
Donc ça a l'air sympa.
Et maintenant, il y a un x dans 3.
C'est maintenant au tour du joueur 2.
Je vais laisser faire quelque chose d'invalide.
Il dit des mouvements invalides, il fait une pause.
Je frappe retour, je reçois pour revenir joueur 2.
Maintenant j'en frappe un, redessine avec le o dans un seul endroit.
Et je continue cela jusqu'à ce que nous avons un gagnant ou un perdant.
Alors causons un gagnant pour o so.
Maintenant x va être, 2 o est va être 5, x va être 6
et o va être 9.
Jeu terminé parce que nous venons de tirer 3 0.
Donc la seule chose que j'ai oubliée était après la boucle while pour afficher les
félicitations que vous avez gagnées.
Et tout ce que nous avons à faire c'est nous devons vérifier l'état du jeu.
Si le statut du jeu est égal à un, cela signifie un joueur un et ce serait
le dernier joueur à gagner.
Donc nous imprimerions le joueur pour cent d gagne.
Sinon, nous allons pour simplement imprimer un tirage au sort.
Parce que si nous sortons de notre boucle et le statut était
négatif, nous savons que le jeu était terminé et a eu un résultat,
il se pourrait donc que nous ayons ce dernier instruction pour afficher les résultats.
Alors maintenant, exécutons-le à nouveau en tant que gagnant.
Et maintenant nous allons en fait voir quelqu'un gagner.
Alors je vais juste mettre en valide nombres ici,
provoquent une victoire rapide pour x et doivent le faire dans ce programme parce que celui-ci disparaît.
Voilà, le premier joueur gagne et il a joué un autre beau son là-bas.
C'était donc une longue conférence.
Je m'excuse pour la longue conférence.
Etudiez ce code, je vais fournissez-le comme fichier source.
J'espère en apprendre beaucoup sur méthodes pour diviser pour conquérir.
Merci