Discussion :

[solarquantum2]

Bonjour à tous,
j'essai de developper un jeu de plateforme mais j'ai une erreur à franchir d'abord. Je voudrais creer un tableau à 2 dimentions d'une structure concernant mes tiles. Mais malheuresement j'obtiens l'erreur suivante :
cannot convert 'tileset*' to 'tileset**' for argument '1' to 'void test(tileset**)'.

J'ai mit mon code pour bien visualiser le soucis.

Est-ce qu'on peut m'aider svp?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
using namespace std;
 
struct tileset {
 
    int type;
    int etat;
    int plan;
};
 
tileset tile[50];
 
void test(tileset *tile[])
{
    cout << tile[0]->type << "\n";
}
 
int main()
{
    test(&tile);
 
    return 0;
}

[dalfab]

Bonjour,

tile et &tile sont la même chose (seul cas pour les tableaux), car un tableau est immédiatement transformé en pointeur.
Ici il faut recevoir un pointeur (qui sera utilisable comme un tableau)
par au choix :

Code :

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

1
2
3
4
5
6
7
8
void test(tileset tile[])
{
cout << tile[0]->type << "\n";
}
void test(tileset *tile)
{
cout << tile[0]->type << "\n";
}

Les deux fonctions sont en fait les mêmes (on ne peut pas passer en paramètre un tableau)

[solarquantum2]

Merci dalfab,
mais en fait je doit le faire pour un tableau à 2 dimentions. Si je rajoute [] au tile[] ca me ressort encore une erreur.

J'espere que tu lira ce message.

Bonjour,

tile et &tile sont la même chose (seul cas pour les tableaux), car un tableau est immédiatement transformé en pointeur.
Ici il faut recevoir un pointeur (qui sera utilisable comme un tableau)
par au choix :

Code :

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

1
2
3
4
5
6
7
8
void test(tileset tile[])
{
cout << tile[0]->type << "\n";
}
void test(tileset *tile)
{
cout << tile[0]->type << "\n";
}

Les deux fonctions sont en fait les mêmes (on ne peut pas passer en paramètre un tableau)

[rnr72]

Bonjour solarquantum2,

si je comprends bien tu cherches à avoir un tableau à 2 dimensions pour les coordonnées de tes tuiles.

Il existe des astuces pour travailler avec un tableau 1d avec des coordonnées 2d

Code :

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

1
2
3
4
5
6
7
8
9
 
#define TAILLE 50
 
int x = 15
int y = 2;
 
Tileset tile[TAILLE * TAILLE];
 
tile[x + y*TAILLE];

Mais tu constatera vite que ce n'est pas ton seul problème, tes structures ne sont pas initialisées donc ton tableau est remplit de structures vides.


P.S.: le #define doit être placé avant le main()

[solarquantum2]

merci de ta reponse mais ce n'est pas encore ca.

Moi j'ai deja le tableau de structure tileset tile[50][50] (qui marche) mais j'ai besoin de le faire passer en argument dans mes fonctions. Je ne veux pas de variable globals dans mon jeu...
Dans le code suivant ca plante car il y a plus d'une dimention.

Code :

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

1
2
3
4
void test(tileset *tile)
{
    cout << tile[0][0].type << "\n";
}

Ce dont j'ai besoin c'est de faire passé en argument ce tableau de structure.

Bonjour solarquantum2,

si je comprends bien tu cherches à avoir un tableau à 2 dimensions pour les coordonnées de tes tuiles.

Il existe des astuces pour travailler avec un tableau 1d avec des coordonnées 2d

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#define TAILLE 50
 
const int tailleTableau = TAILLE * TAILLE;
 
int x = 15
int y = 2;
 
Tileset tile[tailleTableau];
 
tile[x + y*TAILLE];

Mais tu constatera vite que ce n'est pas ton seul problème, tes structures ne sont pas initialisées donc ton tableau est remplit de structures vides.


P.S.: le #define soit être placé avant le main()

[solarquantum2]

Ce dont j'ai besoin c'est de faire passé en argument ce tableau de structure et de pouvoir le modifier depuis la fonction. Donc j'ai besoin d'un pointeur.
Mais je n'y arrive pas quand y'a 2 dimentions. Avec une j'y arrive.

Aidez moi svp.

[rnr72]

Dans le code que je t'ai donné, il n'y a pas de variable globale. Les #define ne sont pas par définition des variables.

Pour ton histoire de tableaux, je t'ai donné la solution. C'est beaucoup plus simple de travailler avec un tableau 1d effectivement.

[solarquantum2]

Le probleme pour moi est de pouvoir passer mon tableau 2d de struct en argument dans le but de le modifier comme si c'etait un tableau en variable global. Ceux ci grace au pointeur.

Dans le code que je t'ai donné, il n'y a pas de variable globale. Les #define ne sont pas par définition des variables.

Pour ton histoire de tableaux, je t'ai donné la solution. C'est beaucoup plus simple de travailler avec un tableau 1d effectivement.

[rnr72]

si tu veux te prendre la t^te pour rien libre à toi.

Code :

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

1
2
3
4
void test(tileset tile[][50])
{
    cout << tile[0][0].type << "\n";
}

[solarquantum2]

merci ca ca marche. Je prefere garder la 2d car c un tableau tile[y][x] c'est important tout les codes de jeux de plateformes sont comme ca.
Je trouve ca bizarre de n'utiliser aucun pointeur. Peut etre tu me dirait que le passage d'un tableau se fait par un pointeur...

Donc cela nous donne le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
using namespace std;
 
struct tileset {
    int type;
    int etat;
    int plan;
};
 
 
 
void test(tileset tile[50][50])
{
 
    cout << tile[0][0].type << "\n";
    tile[0][0].type=20;
}
    //typedef struct s_position s_position;
    struct s_position
    {
            int p_x;
            int p_y;
    };
 
int main()
{
    tileset tile[50][50];
 
    tile[0][0].type=10;
    test(tile);
    cout << tile[0][0].type << "\n";
    return 0;
}

si tu veux te prendre la t^te pour rien libre à toi.

Code :

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

1
2
3
4
void test(tileset tile[][50])
{
    cout << tile[0][0].type << "\n";
}

[rnr72]

Si tu as des codes sources de jeux 2D qui utilise des variables de tableaux à deux dimensions, je serai intéressé de pour les voir, par curiosité et pour enrichir mes connaissance.

Personnellement, je pense que même pour la 3D on utilise des tableaux 1d.

[solarquantum2]

Sinon j'aime pas trop commencer ma fonction comme ca : void drawmap(tileset tile[50][50]) c'est les 50 ca me gene il doit y avoir une autre solution...mais ca fonctionne.

Si tu as des codes sources de jeux 2D qui utilise des variables de tableaux à deux dimensions, je serai intéressé de pour les voir, par curiosité et pour enrichir mes connaissance.

Personnellement, je pense que même pour la 3D on utilise des tableaux 1d.

[rnr72]

Il faut bien l'admettre, tu as raison, on peut bien utiliser des tableaux à deux dimensions.

[solarquantum2]

Ca permet une grande souplesse dans la detection des collisions avec la map et permet aussi de n'afficher que ce qu'on a besoin de la carte plus directement. Ca a pleins d'avantage.

Merci pour ce lien.

Il faut bien l'admettre, tu as raison, ils utilisent bien des tableaux à deux dimensions.

[dragonjoker59]

Et niveau perfs, c'est tout pourri...
Tableau à 1 dimension, avec accesseurs te permettant de simuler les 2.

[Iradrille]

Ca permet une grande souplesse dans la detection des collisions avec la map et permet aussi de n'afficher que ce qu'on a besoin de la carte plus directement. Ca a pleins d'avantage.

Ça n'a presque que des inconvénients. On peut rajouter une couche d'abstraction sur un tableau à 1 dimension pour l'interpréter comme un tableau à 2 / 3 (ou plus si besoin) dimensions.

Comme ça on cumule les avantages des deux solutions : 1 dimension pour les perfs, 2 / 3 dimensions pour la facilité d'usage.

[solarquantum2]

Sinon pour passer un tableau à plusieur dimention sans se prendre la tete on peut le faire au travers une structure genre:

struct carte {
int tile[200][50];
};

et apres se sert des pointeurs.
Comme dans le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
 
using namespace std;
 
struct tileset {
    int x;
    int y;
    int w;
    int h;
    int passe;
    int nbimageptick;
    int numimage;
    int cpimage;
    int point;
    int couleur;
    int depend;
    int type;
    int etat;
    int plan;
};
 
struct carte {
    tileset tile[50][50];
    int type;
    int etat;
    int plan;
};
 
 
void test(carte *map)
{
    cout << map->tile[0][0].type << "\n";
    map->tile[0][0].type=20;
}
 
 
 
int main()
{
    carte map;
    map.tile[0][0].type=10;
    test(&map);
    cout << map.tile[0][0].type << "\n";
 
 
    return 0;
}

Ça n'a presque que des inconvénients. On peut rajouter une couche d'abstraction sur un tableau à 1 dimension pour l'interpréter comme un tableau à 2 / 3 (ou plus si besoin) dimensions.

Comme ça on cumule les avantages des deux solutions : 1 dimension pour les perfs, 2 / 3 dimensions pour la facilité d'usage.

[Invité]

Si les tailles sont statiques, c'est effectivement plus pratique d'utiliser un vrai tableau 2D et ce n'est pas moins performant car le compilateur va l'implémenter automatiquement sous forme de tableau 1D.
Par contre, il faut effectivement spécifier la taille sinon le compilateur ne peut pas faire le calcul d'indice 2D -> 1D.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
 
const int TAILLE_CARTE = 3;
using carte_t = int[TAILLE_CARTE][TAILLE_CARTE];
 
void resetMoitieCarte(carte_t & carte) {
    int * tab = (int*) carte;
    int taille = TAILLE_CARTE*TAILLE_CARTE;
    for (int k=0; k<taille/2; k++)
        tab[k] = 42;
}
 
int main() {
    carte_t c = { 1,2,3,  4,5,6,  7,8,9 };
    resetMoitieCarte(c);
    for (int i=0; i<TAILLE_CARTE; i++)
    {
        for (int j=0; j<TAILLE_CARTE; j++)
            cout << c[i][j] << ' ';
        cout << endl;
    }
    return 0;
}

[dragonjoker59]

car le compilateur va l'implémenter automatiquement sous forme de tableau 1D.

Testé avec tous les compilateurs, je suppose?

[Invité]

Testé avec tous les compilateurs, je suppose?

L'implémentation 2D contigüe n'est effectivement pas garantie dans la doc mais en pratique c'est très souvent le cas (voir la discussion : http://stackoverflow.com/questions/7...guous-1d-array).

Donc, pour le cas du tableau 2D statique, je ne vois pas pourquoi choisir un tableau 1D "géré à la main", qui est plus compliqué, moins robuste et dont le gain de performances n'est pas démontré (mais si quelqu'un a des benchmarks sérieux à ce sujet, je suis très intéressé...).