les tableaux et le pointeur !prob

Version imprimable

Salut à tous je ss debutant en C .... j aime bcp de trouver la solution de mon prob chez vous ...
bon , ...

Nous avons vu que le mode de transmission par valeur semblait interdire à une fonction de modifier la valeur de ses arguments
effectifs et nous avions mentionné que les pointeurs fourniraient une solution à ce problème.

j ai essayé deja avec les variables , et aprés le deroulement ce code fonction trés trés bien §....

mais j aime a faire ça avec les tableau et les enregistrements ...
comment on peut faire ça .... !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 /**************************************/ void echange(int * i,int * l) { int x; x=*l; *l=*i; *i=x; } /**********************************/ void tab(int *t[2]; int *k[2], struc *strr ) { int n; n=0; *t[1]=n; n=1; *t[2]=n; *k[]=*t[]; // printf("%d %d",t[1],t[2]); }

Euh, je suis désolé, mais sur le coup, je n'ai rien compris a ce que tu racontait :?

Deux trois conseil pour améliorer la lisibilité de ton post :

Lorsque tu post un code, il faut que tu utilise les balise code Elles se situe au dessus de la ou tu ecrit et la symbole est un diese en gras. La balise est comme ceci [ C O D E ] [ / C O D E ] sauf qu'il n'y a pas d'espace.
Code:

1 2 3 4 5 6 7 void echange(int *i, int *l) { int x = (*l); (*l) = (*i); (*i) = x; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /* /!\ Attention, pas de ; entre les different argument void tab(int *t[2], int *k[2], struc *strr ) { int n = 0; *t[1]=n; n=1; *t[2]=n; *k[]=*t[]; // printf("%d %d",t[1],t[2]); }
Bon, si j'ai bien comprit, tu souhaite changer des valeur de par des fonctions en passant des pointeur. Apparemment, tu as réussi avec des variable, mais tu voudrais savoir comment faire avec des tableaux ou des structure (parce que enregistrement, a part en pascal, ca me dit rien en C).

Il faut que tu lise des didactitiel sur les tableau en C. Developpez propose cela.

Si ton tableau est declarer statiquement ou dynamiquement, on ne le passe pas de la meme maniere.
Code:

1 2 3 4 5 6 7 /* t est un tableau allouer statiquement alors que k est un pointeur sur un tableau allouer dynamiquement */ void tab(int t[], int *k) { }
Pourrait tu poster un code minimal avec le main afin de bien voir e qui ne va pas ?

Citation:
Envoyé par SofEvans
Si ton tableau est declarer statiquement ou dynamiquement, on ne le passe pas de la meme maniere.
Code:

1 2 3 4 5 6 7 /* t est un tableau allouer statiquement alors que k est un pointeur sur un tableau allouer dynamiquement */ void tab(int t[], int *k) { }
Ah bon, pour faire simple essaies les écritures suivantes :
Code:

1 2 3 void tab(int t[], int k[]) void tab(int *t, int *k)

28/07/2009, 02h30
SofEvans

ssmario >> Je me suis trompé ?

Ca fait longtemps que je declare toujours *t car mes tableaux sont alloué dynamiquement ( ou je suis sur du C++ ).
Je pensais vraiment qu'il y avait deux maniere, c'est faux ?
28/07/2009, 13h32
orfix
Oui, dans ce contexte c'est pareil.
Le nom du tableau est toujours converti en un pointeur vers son premier élément, sauf dans les cas suivants :
- Devant l'opérateur sizeof
- Devant l'opérateur &
- Une chaîne littérale utilisée pour l'initialisation d'un tableau
d'où cette équivalence d'écriture, comme avec :
Code:

1 2 3 4 5 int t[16]; int *p = t; p[3] == t[3] == *(p+3) == *(t+3)
28/07/2009, 15h57
diogene
Citation:
Le nom du tableau est toujours converti en un pointeur vers son premier élément, sauf dans les cas suivants :

Devant l'opérateur sizeof
Devant l'opérateur &
Une chaîne littérale utilisée pour l'initialisation d'un tableau
C'est plutôt derriere ou avec les opérateurs ....
La chaîne littérale n'ayant pas d'identificateur, la question ne se pose pas

;)
28/07/2009, 17h08
orfix

Citation:

Envoyé par diogene

La chaîne littérale n'ayant pas d'identificateur, la question ne se pose pas
;)

En effet :P

Il me semble en voir 2 ou 3 au fond qui font mollement "oui" de la tête, pas encore complètement convaincus ...

Alors, deux fonctions, l'une traitant un 'int *tab', l'autre un 'int tab[]', et des appels en passant un tableau alloué à la compilation et un tableau alloué dynamiquement : c'est pareil !

On peut même passer l'adresse d'un int (c'est de la triche car ça n'est rien d'autre qu'un tableau à 1 élément, alloué statiquement !)

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <stdio.h>
#include <stdlib.h>
 
#define TAB_NB      3
 
void fois_5_stat (int tab[],int nb)
{
    int i;
 
    printf("argument fonction fois_5_stat : %p\n",tab);
 
    for (i=0;i<nb;i++)
        tab[i] = 5 * tab[i];
}
 
void fois_7_dyn (int *tab,int nb)
{
    int i;
 
    printf("argument fonction fois_7_dyn  : %p\n",tab);
 
    for (i=0;i<nb;i++)
        tab[i] = 7 * tab[i];
}
 
int main(void)
{
    int  tab_stat[TAB_NB];
    int *tab_dyn = malloc(TAB_NB*sizeof(int));
    int  single_int;
    int  i;
 
    printf("quid des adresses ?\n");
 
    printf("tab_stat       : %p\n",tab_stat);
    printf("&(tab_stat[0]) : %p\n",&(tab_stat[0]));
    printf("tab_dyn        : %p\n",tab_dyn);
    printf("single_int     : %p\n",&single_int);
 
 
    printf("\ntab_stat (%p) mis en argument\n",tab_stat);
 
    /* remplissage manuel avec 1 */
    printf("au depart ... ");
    for (i=0;i<TAB_NB;i++) {
        tab_stat[i] = 1;
        printf("%d%c",tab_stat[i],(i==TAB_NB-1)?'\n':' ');
    }
 
    /* tableau statique dans fonction avec "tableau statique" */
    fois_5_stat(tab_stat,TAB_NB);
    /* ca donne quoi ? */
    printf("au retour ... ");
    for (i=0;i<TAB_NB;i++)
        printf("%d%c",tab_stat[i],(i==TAB_NB-1)?'\n':' ');
 
    /* tableau statique dans fonction avec "tableau dynamique" */
    fois_7_dyn(tab_stat,TAB_NB);
    /* ca donne quoi ? aie ??? */
    printf("au retour ... ");
    for (i=0;i<TAB_NB;i++)
        printf("%d%c",tab_stat[i],(i==TAB_NB-1)?'\n':' ');
 
    /* traitement analogue avec le tableau alloue dynamiquement */
 
    printf("\ntab_dyn (%p) mis en argument\n",tab_dyn);
 
    printf("au depart ... ");
    for (i=0;i<TAB_NB;i++) {
        tab_dyn[i] = 2;
        printf("%d%c",tab_dyn[i],(i==TAB_NB-1)?'\n':' ');
    }
 
    fois_5_stat(tab_dyn,TAB_NB);
    printf("au retour ... ");
    for (i=0;i<TAB_NB;i++)
        printf("%d%c",tab_dyn[i],(i==TAB_NB-1)?'\n':' ');
 
    fois_7_dyn(tab_dyn,TAB_NB);
    printf("au retour ... ");
    for (i=0;i<TAB_NB;i++)
        printf("%d%c",tab_dyn[i],(i==TAB_NB-1)?'\n':' ');
 
    /* traitement analogue sur l'entier */
 
    printf("\nadresse single_int (%p) mis en argument\n",&single_int);
 
    single_int = 3;
    printf("au depart ... %d\n",single_int);
 
    fois_5_stat(&single_int,1);
    printf("au retour ... %d\n",single_int);
 
    fois_7_dyn(&single_int,1);
    printf("au retour ... %d\n",single_int);
 
    return 0;
}

qui donne à l'exécution

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
quid des adresses ?
tab_stat       : 0xbffff74c
&(tab_stat[0]) : 0xbffff74c
tab_dyn        : 0x100120
single_int     : 0xbffff748
 
tab_stat (0xbffff74c) mis en argument
au depart ... 1 1 1
argument fonction fois_5_stat : 0xbffff74c
au retour ... 5 5 5
argument fonction fois_7_dyn  : 0xbffff74c
au retour ... 35 35 35
 
tab_dyn (0x100120) mis en argument
au depart ... 2 2 2
argument fonction fois_5_stat : 0x100120
au retour ... 10 10 10
argument fonction fois_7_dyn  : 0x100120
au retour ... 70 70 70
 
adresse single_int (0xbffff748) mis en argument
au depart ... 3
argument fonction fois_5_stat : 0xbffff748
au retour ... 15
argument fonction fois_7_dyn  : 0xbffff748
au retour ... 105

Citation:
Envoyé par plxpy
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> #include <stdlib.h> #define TAB_NB 3 void fois_5_stat (int tab[],int nb) { int i; printf("argument fonction fois_5_stat : %p\n",tab); for (i=0;i<nb;i++) tab[i] = 5 * tab[i]; }
Même pour un exemple, je ne comprendrais jamais les gens qui mettent un type int pour la taille d'un tableau...

28/07/2009, 19h15
plxpy

... et pesonne pour demander "pourquoi ?" Zut !!
Comment placer maintenant ce fameux size_t ?

Comme on est sur un forum C / Débuter, je m'y colle

Size_t est LE type de prédilection pour dénombrer des tailles (en octets, d'éléments, ...). On le retrouve dans la série de fonctions (x)alloc, dans memcpy, etc... et ça doit être, de mémoire, mais on me corrigera si besoin, le type retourné par sizeof.

Il eût donc été préférable que je misse un type size_t pour le nombre d'éléments des tableaux. Autant pour moi.

ps : le dire directement aurait fait avancer les choses ... sinon ça reste du bruit
28/07/2009, 20h09
nicolas.sitbon

Citation:

Envoyé par plxpy

Size_t est LE type de prédilection pour dénombrer des tailles (en octets, d'éléments, ...).

En bytes, pas en octet.