Est ce que ce syntaxe est juste ?( a propos des tableaux)

Version imprimable

Salut,
Je suis entrain de créer une Tic-Tac-Toe PLAYER1 vs. PLAYER2, j'ai presque finis le code, mais il reste a savoir si cette partie est juste :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const int taille = 9;//Taille du tableau represente la grille du jeu 3x3
char actions1[ taille]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};//va contenir les carreaux remplits par PLAYER1
char actions2[ taille]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};//va contenir les carreaux remplits par PLAYER2
char grillePrincipale[ taille]={  1, 2, 3, 4, 5, 6, 7, 8, 9};//va etre transmis a l'ecran, elle va contenir X et O et les nombres non-remplis
.
.
.
//aprés quelques changements dans les cases de ces trois tableaux
.
.
.
 
if( condition) //pour réintialiser les icones apres un redemarrage de la partie, condition definie la reintialisation de la partie.
{
    actions1[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
    actions2[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
    grillePrincipale[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
}

En gros, je veux savoir si on peut utiliser la syntaxe raccourcis: tableau[]={valeur1, valeur2, valeur3,...} une deuxieme fois pour changer les valeurs dans les memes tableaux actions1, actions2 et grillePrincipale

10/06/2012, 00h32
Trademark

Salut,

non tu ne peux pas.

Mais une telle question m'étonne, car elle veut peut-être dire que tu n'as pas encore essayé de compiler ton code. Et crois-moi, si c'est le cas, c'est pas le seul problème que tu vas avoir :aie:

Par contre au niveau du design pourquoi ne gardes-tu simplement pas que une grille ? Et dans ce cas, tu choisis des codes adaptés pour représenté vide, joueur 1 et joueur 2.

Et lors de ton initialisation, tu remplis de 1 à 9, est-ce que ça a un quelconque sens ?
10/06/2012, 10h10
3DArchi

Salut,
100% d'accord avec Trademark. Pour savoir si une syntaxe est correcte, le meilleur allié est souvent le compilateur. Tu en trouveras dans la page consacrée pour en installer un sur ton poste. Sinon il existe aussi de compilateurs en ligne.
10/06/2012, 14h39
lahdili.reda

Oui c'est vrai, je me suis rendu compte que ce syntaxe n'est pas mis pour un seul but, celui de l'intialisation, mais aussi pour la taille du tableau, et puisque la taille du tableau est constante durant toute l'execution, alors le C++ refuse de réintialiser le tableau une deuxieme fois avec ce syntaxe.
En ce qui concerne la compilation du code, j'ai essayé durant l'ecriture du code que je ne veux surtout pas des fautes, alors je me lance dans ce defi, j'ai deja lis et relis le code plusieurs fois pour ne pas avoir des fautes, cela va m'aider un peu plus tard dans mes projets...
En ce qui concerne le design du jeu, j'ai essayé d'imiter cette structure :
http://www.java2s.com/Code/CImages/TicTacToe.PNG
en demandant au joueur de choisir le nombre de carreau, apres j'examine ce nombre (s'il n'est pas superieur a 9, s'il n'est pas inferieur ou egal a zero...), puis j'assigne au tableau du PLAYER 1 le X, et ainsi de suite...
J'essayerais de partager avec vous le code source.
Merci encore une fois TradeMark et 3DArchi...

Pour les tableaux, en C++ on préfèrera std::array pour les tableaux statiques et std::vector pour les tableaux dynamiques.

A noter que si tu as un compilateur récent supportant les dernières nouveautés C++11, les listes d'initialisations sont un support pour ce que tu souhaites faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <vector>
#include <array>
 
#include <iostream>
#include <algorithm>
#include <iterator>
 
int main()
{
    static const int SIZE=9;
    std::array<char,SIZE> action1={1,2,3,4,5,6,7,8,9};
    std::vector<char> action2={1,2,3,4,5,6,7,8,9};
 
 
    std::copy(std::begin(action1),std::end(action1),std::ostream_iterator<int>(std::cout," "));
    std::cout<<std::endl;
 
    std::copy(std::begin(action2),std::end(action2),std::ostream_iterator<int>(std::cout," "));
    std::cout<<std::endl;
 
 
    action1 =  std::array<char,SIZE>{9,8,7,6,5,4,3,2,1};
    action2 =  std::vector<char>{9,8,7,6,5,4,3,2,1};
 
    std::copy(std::begin(action1),std::end(action1),std::ostream_iterator<int>(std::cout," "));
    std::cout<<std::endl;
 
    std::copy(std::begin(action2),std::end(action2),std::ostream_iterator<int>(std::cout," "));
    std::cout<<std::endl;
 
    return 0;
}

3DArchi, merci encore une fois, mais je ne suis pas capable de lire ce que tu as ecrit ( je ne suis qu'un novice ), et voila ma solution :

Code:

1
2
3
4
5
6
7
8
9
if( condition)
{
    for ( int subscript=0, intialisation=1; subscript<taille; subscript++, intialisation++)//raccourcis en utilisant for pour affecter les cases des trois tableaux de 0-8 par 1-9 successivement.
        {
             actions1[subscript]=intialisation;
             actions2[subscript]=intialisation;
             grillePrincipale[subscript]=intialisation;
        }
}

Merci...

Bonjour,

pourquoi ne pas faire du C++ et se cantonner à du C ?

Code:

1
2
3
struct Action { void Init(); };
...
if (condition) myActions.Init();

Sinon, si tu veux garder ta syntaxe C, je pense que memcpy ferait l'affaire.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const int taille = 9;//Taille du tableau represente la grille du jeu 3x3
char actions1[ taille]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};//va contenir les carreaux remplits par PLAYER1
char actions2[ taille]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};//va contenir les carreaux remplits par PLAYER2
char grillePrincipale[ taille]={  1, 2, 3, 4, 5, 6, 7, 8, 9};//va etre transmis a l'ecran, elle va contenir X et O et les nombres non-remplis
.
.
.
//aprés quelques changements dans les cases de ces trois tableaux
.
.
.
 
if( condition) //pour réintialiser les icones apres un redemarrage de la partie, condition definie la reintialisation de la partie.
{
    char actions1bis[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
    char actions2bis[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
    char grillePrincipalebis[]={ 1, 2, 3, 4, 5, 6, 7, 8, 9};
    memcpy(actions1, actions1bis, sizeof(actions1));
    memcpy(actions2, actions2bis, sizeof(actions2));
    memcpy(grillePrincipale, grillePrincipalebis, sizeof(grillePrincipale));
}

M'enfin, utiliser une class et des méthodes d'init serait bien mieux.

Par ailleurs, même sans utiliser les concepts du C++, le code que tu nous montres est d'un style étrange.

Code:

1
2
3
4
5
6
7
8
9
if( condition)
{
    for ( int subscript=0, intialisation=1; subscript<taille; subscript++, intialisation++)//raccourcis en utilisant for pour affecter les cases des trois tableaux de 0-8 par 1-9 successivement.
        {
             actions1[subscript]=intialisation;
             actions2[subscript]=intialisation;
             grillePrincipale[subscript]=intialisation;
        }
}

Plutot que deux variable, on utiliserai un peu d'arithmétique

Code:

1
2
3
4
5
6
7
if( condition) {
    for ( int subscript=0; subscript<taille; subscript++) {
         actions1[subscript]=subscript+1;
         actions2[subscript]=subscript+1;
         grillePrincipale[subscript]=subscript+1;
    }
}

Cela dit, la version C++ est plus sûre, et permettra d'avoir du code plus clair dans le reste du projet