Manipulation de pointeur sur tableau dynamique

Version imprimable

Bonjour,

J'ai beau lire des exemples et des cas similaires au mien, je patauge.

Voila un code qui tombe en marche et son warning. J'aimerai trouver une écriture plus propre et comprendre la gravité du warning dans mon cas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int loadPlaylist(ChaisesMusicales* pJeu){
        TypeAudio *audioPtr;
        pJeu->songs = calloc(pJeu->nbSongs, sizeof(TypeAudio));
        // ...
        audioPtr = &pJeu->songs[i];
        (*audioPtr).pathFile = getPathFromElementAudioNameJeu(&pJeu->baseParams, songsNames[i]);
        // ...
}
// avec précédement déclaré :
 
/// \struct TypeAudio
typedef struct{
    char *pathFile;
}TypeAudio;
 
typedef struct ChaisesMusicales
{
    TypeAudio **songs;
    // ...
}
ChaisesMusicales;
 
char* getPathFromElementAudioNameJeu(TypeJeu* pJeu, const char* elementName);

Code:

1
2
3
chaisesMusicales.c:223:50: warning: assignment from incompatible pointer type [enabled by default]
                                         audioPtr = &pJeu->songs[i];
                                                  ^

Auriez-vous une idée pour corriger ma syntaxe ? Merci

08/12/2014, 23h03
diogene
```
pJeu est un  ChaisesMusicales*
pJeu->songs est un  TypeAudio **
pJeu->songs[i] est un  TypeAudio *
&pJeu->songs[i] est un TypeAudio **
```
Or
```
audioPtr est un TypeAudio *
```
Et l'assignation correspond à " TypeAudio * = TypeAudio ** "
les deux types sont différents et il n'y a pas de conversion implicite entre ces deux types.
Surtout ne pas tenter un cast pour masquer cet avertissement : ce simple avertissement traduit pratiquement toujours une erreur fatale dans le code.

Quant à corriger cette erreur, ne connaissant rien de ce que tu veux faire, c'est difficile.
09/12/2014, 09h31
Sve@r

Citation:

Envoyé par vincenet

J'aimerai trouver une écriture plus propre

Bonjour

Déjà nomme tes structures s_xxx et tes types t_xxx. Sinon, comme le dit Diogene, &truc[i] (correspondant à truc + i) est donc forcément du même type que truc...

Jusque là j'arrive à suivre, mais le retour de fonction getPathFromElementAudioNameJeu() qui est un char * ne peut être récupéré sans plantage.
J'essaie de décomposer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        TypeAudio *audioPtr;
        // audioPtr est un TypeAudio *
        // *audioPtr est un TypeAudio
        // (*audioPtr).pathFile est du type de pathFile soit un char *
        char * tmp;
        // tmp est un char *
 
        audioPtr = pJeu->songs[i];
        msg(DEBUG, MSG_PARCOURS, "toujours en vie");
        tmp = getPathFromElementAudioNameJeu(&pJeu->baseParams, songsNames[i]);
        msg(DEBUG, MSG_PARCOURS, "toujours en vie"); // ligne affichée
        (*audioPtr).pathFile = tmp; // y a t-il un problème ici ?
        msg(DEBUG, MSG_PARCOURS, "toujours en vie"); // ligne PAS affichée

Aurai-je encore fait une bourde ?

09/12/2014, 11h18
ternel

Tu compiles bien avec un maximum de warning?

Ca ressemble à un pointeur nul, au pif audioPtr.

Un crash n'intervient qu'a l'accès à la mémoire, donc sur un * ou un ->.
pas sur une copie d'un pointeur, qui est une variable locale, propre, mais contient une adresse (possiblement valide)

Citation:

Envoyé par leternel

Ca ressemble à un pointeur nul, au pif audioPtr.

pJeu->songs vaut 228280
pJeu->songs[0] vaut 0
&pJeu->songs[0] vaut 228280
Code:

1 2 3 audioPtr = pJeu->songs[i]; // pas de warning mais vaut 0 et crash audioPtr = &pJeu->songs[i]; // warning à la compilation mais pas de crash audioPtr = pJeu->songs + i*sizeof(TypeAudio); // warning à la compilation mais pas de crash

09/12/2014, 13h15
ternel

Mais puisqu'il vaut 0, c'est qu'il faut lui donner une valeur AVANT tout ce code.

Tu n'aurai pas oublié de charger/créer la song?
09/12/2014, 13h26
vincenet

J'ai précédemment reservé un espace pour N structures TypeAudio

Code:

pJeu->songs = calloc(pJeu->nbSongs, sizeof(TypeAudio));

Je veux maintenant initialiser l'élément pathFile des structures TypeAudio...
09/12/2014, 13h42
ternel

Donc tu as un pJeu->songs pointant sur de la mémoire (mise à 0) correspondant à nbSongs TypeAudio.

pJeu->songs[i] est donc un TypeAudioDonc, moi, j'écrirai bien quelque chose comme ceci:

Code:

audioPtr = &(pJeu->songs[i]);

Si ca ne marche pas sans warning ni crash, c'est que tu devrais ne pas passer par un pointeur audioPtr (cf ma signature), et que je n'ai pas vraiment saisi tout ton problème
09/12/2014, 14h01
vincenet

Et de quel type serait l'élément pJeu->songs ? TypeAudio ** ou TypeAudio * ???
09/12/2014, 17h11
Sve@r
Citation:
Envoyé par vincenet

Code:

1 2 pJeu->songs vaut 228280 &pJeu->songs[0] vaut 228280
Evidemment puisque comme je l'ai dit précédemment, &pJeu->songs[i] vaut pJeu->songs + i. Donc fatalement &pJeu->songs[0] vaut pJeu->songs + 0 !!!
Citation:
Envoyé par vincenet

Code:

1 2 audioPtr = pJeu->songs[i]; (*audioPtr).pathFile = tmp; // y a t-il un problème ici ?
Oui il y a un problème si audioPtr (donc si ptJeu->songs[i]) ne contient pas une adresse valide. Mis à part ça, ça s'écrit aussi audioPtr->pathFile = tmp...

Citation:

Envoyé par vincenet

audioPtr = pJeu->songs[i]; // pas de warning mais vaut 0 et crash

Ben voilà. Si audioPtr vaut 0 tu ne peux évidemment pas aller voir *audioPtr !!!

Citation:

Envoyé par vincenet

J'ai précédemment reservé un espace pour N structures TypeAudio

Code:

pJeu->songs = calloc(pJeu->nbSongs, sizeof(TypeAudio));

Et tu ne sais pas que calloc() met tout à 0 ??? :roll:
Fatalement ptJeu->songs[i] vaut 0 donc audioPtr vaut 0 donc aller remplir (*audioPtr).pathFile pose un sérieux problème !!!
09/12/2014, 17h33
vincenet

Merci pour ta participation Sve@r.

Je sais bien que calloc met à 0 et c'est volontaire car je ne souhaite pas stocker des adresses mais des données.

Je sais maintenant lire les erreurs, mais j'ai encore un pas à faire pour les corriger... Tu n'as pas réagis à ma dernière question ?

Citation:

Envoyé par vincenet

Je sais bien que calloc met à 0 et c'est volontaire car je ne souhaite pas stocker des adresses mais des données.

Je ne vois pas trop le rapport. Initialiser à 0 sert quel que soit l'élément que l'on veut stocker ensuite. Toutefois, quand on a des étoiles dans les types, c'est que tout de même ce sont des adresses que l'on veut stocker. Ceci dit de toute façon même une adresse est quand-même quelque part une donnée...

Citation:

Envoyé par vincenet

Tu n'as pas réagis à ma dernière question ?

Le type de pJeu->songs ??? Ben si la structure
Code:

1 2 3 4 5 typedef struct ChaisesMusicales { TypeAudio **songs; // ... }
n'a pas changé c'est évidemment du type du membre nommé "song" donc un TypeAudio**. Ce qui m'amène d'ailleurs à cette question à savoir pourquoi un pointeur double ? Tu veux donc gérer une matrice de TypeAudio ??? Je crois que c'est là le problème... surtout que ton calloc alloue N "TypeAudio" alors qu'il devrait allouer N "TypeAudio*" !!!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 typedef struct ChaisesMusicales { TypeAudio *songs; // ... } int loadPlaylist(ChaisesMusicales* pJeu){ TypeAudio *audioPtr; pJeu->songs = calloc(pJeu->nbSongs, sizeof(TypeAudio)); // ... audioPtr = &pJeu->songs[i]; audioPtr->pathFile = getPathFromElementAudioNameJeu(&pJeu->baseParams, songsNames[i]); // ... }