Bonjour à tous,
 
Pourriez vous m'eclairer & me dire pourquoi ceci ne fonctionne pas:

 
alors que ceci fonctionne:

 
Apparement quand j'essaye de manipuler case par case ca segfault (de même pr strcpy par exemple) mais quand je lui définie une valeur directement, cela fonctionne, c'est sans doute un problème de pointeur mais là j'avoue ne pas savoir quoi faire ?
 
Merci pour votre aide!

map n'est pas un char ** (pointeur sur pointeur)
 
 

parce que t'es map[x] ne sont pas initialisés.

Bein meme si je les initialise de cette façon:

 
et que ensuite je fasse:

Ca plante, pourtant en lecture ca passe nikel ??

ou ça, en fait ça dépends ce qu'il veut faire le monsieur  

bein moi je cherche juste à stocker des char dans un tableau, charactere par charactere !

moi ce qui me gène c'est ton SIZEX*SIZEY.
qu'est ce que tu veux faire, manipuler un tableau de char 2D, ou un tableau de pointeurs ?
si c'est un tableau de pointeurs char** est ok, mais la taille de la shm serait plustôt PTR_COUNT*sizeof( char* ).
 
autrement si tu comptes mettre en shm 10 chaines de 10 caractères max, tu te mets les pieds dans le tapis.

Comment est déclarée ta variable map ?

 
ok.
 
donc  
char *map;
et pas char **map;
 
for( i = 0; i < SIZEY; i++ )
{
    char *dst_string = map + SIZEX * i;
    strncpy( dst_string, "plouf", SIZEX );
}
 
et là tu as 10 (SIZEY) ploufs tous les 10 (SIZEX) char.

 
Oui moi c'est plutot ca que je veux faire, mon map est déclaré comme un -> char **map

 
Oui j'avais déja vu ca mais j'ai pas trop compri l'histoire, je vais pouvoir y acceder comme un tableau 2D après ?

d'un point de vue déroulage mémoire, un tableau 2D est un tableau 1D ou les lignes sont les unes derrière les autres.
 
---
 
la confusion classique est qu'un "type **truc", c'est n'est pas un pointeur sur un tableau 2D, c'est un pointeur sur pointeur et du coup les offsets n'ont plus rien à voir.

Oui je suis d'accord mai d'un point de vue technique est ce que je vais pouvoir le manipuler comme map[2][3], etc...après?

oui et non
 
si tu déclares une fonction style:
 
void plop( char *ptr )
{
}
 
la taille de la ligne est "perdue", et il faut le faire à la main. style  
 
char plop( char *ptr, int x, int y )
{
   char *spot = ptr + x + y * SIZEX;
   return *spot;
}
 
par contre si tu déclares une fonction style:
 
char puick( char tab[SIZEY][SIZEX], int x, int y )
{
    return tab[y][x];
}
 
le compilo peut déterminer l'adresse correctement (si je me mets pas les pieds dans le tapis)
 
le problème étant que ça reste valide pour des dimensions statiques, mais si tu dois utiliser des dimensions variables cette approche tombe.

Oui moi c'est statique, je défini la taille ds les define & j'y touche plus donc en principe ce serait ca pour moi...

 
C'est dingue quand même qu'il n'y ai aucun autre moyen de gerer ca c'est pas possible >_<
 
Ce que je comprend pas non plus c'est que pourtant quand je fait de la lecture char par char ca fonctionne

Donc je pointe forcément au bon endroit ? o_O  

nan là tu vas mettre ton doigt dans le cul du diable

t1 ca fait chier cette histoire quand même foutu SHM  
Merci pour votre aide )

rien à voir avec les shm, ça a avoir avec l'adressage en C.
 
avec un **map comme déclaration de type,
 
un map[y][x], va chercher le y-ième (en fait +1 vu que le premier est le 0-ième) pointeur (de pointeur de char) à partir de map, puis à partir de cette adresse va chercher le x-ième pointeur.
 
avec un printf( "%c"  ), tu cast ce pointeur en en char pour l'afficher.
 
donc avoir un printf("%c ",map[y][x]), est encore plus faux que printf("%c ",*map[y][x])  
dans le premier tu affiche le pointeur casté en char, alors que dans le deuxième tu affiche un char.
 
mais vu que ton espace mémoire est en vrac, à la limite c'est moins pire. (le cul du diable ou ses laterines)
vu que map[y][x], va faire un seul accès mémoire débile (pour obtenir le pointeur [x], en supposant que le pointeur [y] soit dans l'espace de la shm)
alors que *map[y][x] te fera un double accès débile. (le pointeur[x] puis la déférence de ce pointeur pour obtenir le char de l'espace intersidéral)  
 
avec un char tab[SIZEY][SIZEX], le compilo fait ce que tu lui demande, il va chercher le char aux coordonnées x,y.

 
Oui mais dans ce cas là je le déclare comment le tableau?

Ca peut marcher?

t'as un problème de C là: . Travaille déjà à comment allouer une matrice avec un seul malloc. Ensuite tu transpose.
 
C'est moche cette histoire de * décalage.
 
Alloue N pointeurs + N x M x sizeof(Element).
Tu remplis les N pointeurs pour pointer vers le bon morceau à l'adresse i x M x sizeof(Element) et c'est bon. Après tu peux a[n][m];

oki jvé essayer de voir ca !
 
Merci pr ton aide!

On à traiter 100x le cas d'allouer une matrice avec un seul malloc. Réfléchi un peu ou fais une recherche.

 
 
char *shm = shmat( ... )
process( shm );
 
avec:
 
void process( char tab[SIZEY][SIZEX] )
{
}
 

 
j'ai un peu peur qu'il se perde
de plus si les pointeurs sont dans la shm, il risque d'avoir des surprises.

y a pas de raison. shm ou malloc c'est pareil. pas le peine de ce lancer dans des trucs compliqués si on ne maitrise pas.
d'ailleurs pour ce tableau de chaines, si la taille des chaines est fixe, c'est tout a fait possible de faire ça super simplement avec un pointer de char[N] et en allouer M.
 
Mais oui c'est les bases du C, pas la peine d'aller plus loin si on ne les a pas.

Bein les malloc & tout j'ai aucun soucis, c'est juste la manipulation en mémoire qui est un peu plus nouvelle pour moi, je vais tester & voir !

ce que je veux dire, c'est que le pointeur direct sur une ligne de matrice dans la shm, peut être invalide d'un process/binaire à un autre suivant où est projetée la shm dans l'espace d'adressage.  
donc un offset depuis le début de la shm oui, mais un pointeur absolu danger (dans le cas de la shm), ceci dit ça lui fera faire de l'exercice

c'est vrai. Vu qu'il faut bien allouer quelque chose pour que tout tienne en SHM, tes chaines sont à taille fixe. Ca se fait un un seul malloc