1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même ?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau *tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier,
il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même ?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau *tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier,
il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même ?
# A cette étape, que vaut tab ?
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau *tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
# Mais alors, où était stocké le tableau avant cette procédure ???
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
(1) : *x est un entier,
il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Auquel cas, la variable x contient l'adresse de n.
*x a également changé, il contient désormais la valeur de n ?
Si on change la valeur de n, celle de *x change aussi non ?
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Enfin, ma dernière question :
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Quelqu'un peut-il me dire si mes définitions sont exactes ? (pour
faciliter
la lecture, mes questions sont précedées du symbole #)
1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
C'est effectivement nécessaire, mais ce n'est pas nécessairement un intérêt,
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
Oui : pouvoir décider de la taille du tableau, et même de son existence en 1
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
Et non ;-)
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
Oui, c'est ça. reformulons toutefois, aucun tableau n'existe en tant que tel
# Mais alors, où était stocké le tableau avant cette procédure ???
Y'en avait pas, voir plus haut ...
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
Eh non ...
int nU;
cout << &n;
Affiche l'adresse de n.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
int*, pointeur sur int
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
[Ici, le passage par NULL n'est pas une obligation, même de style :
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
oui, NULL vaut 0. Mais c'est un peu ambiguë. Laissez tomber pour l'instant.
x=&n; (2)
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Perdu ! Bon, je pense que maintenant c'est plus clair : on change la valeur
Auquel cas, la variable x contient l'adresse de n.
Oui !!!! C'est à dire la même valeur que &n.
*x a également changé, il contient désormais la valeur de n ?
*x n'est qu'un symbole, celui du déréférencement de x.
Si on change la valeur de n, celle de *x change aussi non ?
On s'accroche :
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Si vous faites :
Enfin, ma dernière question :
J'y crois pas ...
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
Sincèrement, votre démarche est bonne, mais il vous faut absolument être
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Je pense que tout ce qui précède devrait vous aider ...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
C'est un plaisir. Ça ne peut pas nuire de refaire le points sur les
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
C'est pourtant utile. Trop de clavier nuit, mais pas du tout ......
Merci encore
Cordialement,
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Quelqu'un peut-il me dire si mes définitions sont exactes ? (pour
faciliter
la lecture, mes questions sont précedées du symbole #)
1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
C'est effectivement nécessaire, mais ce n'est pas nécessairement un intérêt,
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
Oui : pouvoir décider de la taille du tableau, et même de son existence en 1
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
Et non ;-)
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
Oui, c'est ça. reformulons toutefois, aucun tableau n'existe en tant que tel
# Mais alors, où était stocké le tableau avant cette procédure ???
Y'en avait pas, voir plus haut ...
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
Eh non ...
int nU;
cout << &n;
Affiche l'adresse de n.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
int*, pointeur sur int
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
[Ici, le passage par NULL n'est pas une obligation, même de style :
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
oui, NULL vaut 0. Mais c'est un peu ambiguë. Laissez tomber pour l'instant.
x=&n; (2)
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Perdu ! Bon, je pense que maintenant c'est plus clair : on change la valeur
Auquel cas, la variable x contient l'adresse de n.
Oui !!!! C'est à dire la même valeur que &n.
*x a également changé, il contient désormais la valeur de n ?
*x n'est qu'un symbole, celui du déréférencement de x.
Si on change la valeur de n, celle de *x change aussi non ?
On s'accroche :
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Si vous faites :
Enfin, ma dernière question :
J'y crois pas ...
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
Sincèrement, votre démarche est bonne, mais il vous faut absolument être
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Je pense que tout ce qui précède devrait vous aider ...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
C'est un plaisir. Ça ne peut pas nuire de refaire le points sur les
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
C'est pourtant utile. Trop de clavier nuit, mais pas du tout ......
Merci encore
Cordialement,
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Quelqu'un peut-il me dire si mes définitions sont exactes ? (pour
faciliter
la lecture, mes questions sont précedées du symbole #)
1)
# L'interet d'un tableau dynamique par rapport à un tableau statique est
qu'on peut liberer la mémoire utilisée par le tableau lorsqu'on a finit de
l'utiliser ?
C'est effectivement nécessaire, mais ce n'est pas nécessairement un intérêt,
# Ca apporte juste l'avantage de pouvoir "gerer" la mémoire ?
# Y-a-t-il d'autres avantages ?
Oui : pouvoir décider de la taille du tableau, et même de son existence en 1
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
--> La déclaration :
int *tab = NULL;
# Ici on "réserve" un emplacement mémoire pour un tableau contenant des
entiers (int). Ses valeurs sont stockées dans *tab (par exemple (*tab)[0]
renverrais le 1er élement si on l'avait définit). Son adresse est stockée
dans tab.
# Ici ce qu'on affecte à la valeur NULL, c'est bien le tableau en lui même
?
# A cette étape, que vaut tab ?
Et non ;-)
--> L'allocation mémoire :
tab = new int[taille];
Ici je n'ai pas très bien compris.
# Apparemment, on change la valeur de tab qui est l'adresse du tableau
*tab
?
# On lui applique une nouvelle adresse à l'aide de la commande new ?
Oui, c'est ça. reformulons toutefois, aucun tableau n'existe en tant que tel
# Mais alors, où était stocké le tableau avant cette procédure ???
Y'en avait pas, voir plus haut ...
# En clair, les 2 lignes suivantes effectuent la même opération : renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
Eh non ...
int nU;
cout << &n;
Affiche l'adresse de n.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
int*, pointeur sur int
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
[Ici, le passage par NULL n'est pas une obligation, même de style :
(1) : *x est un entier, il a la valeur NULL (cad 0 ?), son adresse est
quelconque...
oui, NULL vaut 0. Mais c'est un peu ambiguë. Laissez tomber pour l'instant.
x=&n; (2)
(2) : on change l'adresse x de *x, sa nouvelle adresse est celle de n.
Perdu ! Bon, je pense que maintenant c'est plus clair : on change la valeur
Auquel cas, la variable x contient l'adresse de n.
Oui !!!! C'est à dire la même valeur que &n.
*x a également changé, il contient désormais la valeur de n ?
*x n'est qu'un symbole, celui du déréférencement de x.
Si on change la valeur de n, celle de *x change aussi non ?
On s'accroche :
Réciproquement, si on change la valeur de *x (est-ce possible ?),
qu'advient-t-il d ela valeur de n ?
Si vous faites :
Enfin, ma dernière question :
J'y crois pas ...
Dans une procédure qui utilise un tableau T comme argument, une définition
possible est :
Sincèrement, votre démarche est bonne, mais il vous faut absolument être
void ma_fonction ( int T[ ] )
(dans le cas où la fonction renvoie void et où le tableau contient des
entiers).
Or le prof nous a donné une autre définition qui focntionne aussi et qui
est, selon lui, "plus générale" :
void ma_fonction ( int *T )
# Y-a-t-il un lien entre cette écriture et l'opérateur * (*x = valeur
contenue à l'adresse x) ?
Je pense que tout ce qui précède devrait vous aider ...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
C'est un plaisir. Ça ne peut pas nuire de refaire le points sur les
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
C'est pourtant utile. Trop de clavier nuit, mais pas du tout ......
Merci encore
Cordialement,
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS],
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS],
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS],
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
Bonjour, je ne suis pas sur de bien comprendre le fonctionnement des
tableaux dynamiques...
Merci à ceux qui ont eu le courage de lire mon (long) message jusqu'au
bout
;-)
Si vous pouviez répondre à mes questions, je vous en suis reconnaissant.
N'ayant que mon cours "papier" sur moi, je ne suis pas en mesure de tester
toutes mes suppositions sur un compilateur :-(
Merci encore
RCV
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS], si ca t'interesse
vraiment de programmer en C il faut aller sur fr.comp.lang.c.
Bon, vais essayer d'y repondre un peu quand meme.
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Nous sommes en 2004, il est pertinennt de faire un cours de C++ "from
Relis ton cours de C, et reecris correctement ta ligne de code :
Pourquoi aurait-il un cours de C ? Le C++ est un langage autonome.
int* tab=NULL;
et non
int *tab=NULL,
tab est de type int*.
C'est mon choix également, comme dirait notre Marianne.
# En clair, les 2 lignes suivantes effectuent la même opération :
renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
euh... pas de compilo sous la main, mais ca ne devrait pas faire la meme
chose... le deuxieme devrait bien renvoyer l'adresse de 55. le 1er,
plantage : tu demandes d'afficher le contenu de l'adresse 55, celle-ci
ne doit pas etre a toi. int* nU dit au compilo que *n est situé a
l'adresse 55.
Le second renvoie l'adresse de n, &n, c'est trivial.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
ben non : l'adresse de n, comme tu l'as dit juste avant, et comme tu l'a
ecrit la (& signifie adresse de...)
Oui, c'est une valeur affectable à une lvalue de type int*.
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
int *x=&n;
int* x = &n;
(1) : *x est un entier,
non : int*, donc pointeur sur entier.
Ben si, *x désigne un entier, si x est valide.
Je sais, le C/C++ c'est merdique avec les pointeurs, un meme signe
signifie deux choses differentes suivant l'utilisation, faut faire avec :)
Et que dire de & !!!!
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Déjà commenté l'aspect autonome, à mon sens, du C++.
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS], si ca t'interesse
vraiment de programmer en C il faut aller sur fr.comp.lang.c.
Bon, vais essayer d'y repondre un peu quand meme.
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Nous sommes en 2004, il est pertinennt de faire un cours de C++ "from
Relis ton cours de C, et reecris correctement ta ligne de code :
Pourquoi aurait-il un cours de C ? Le C++ est un langage autonome.
int* tab=NULL;
et non
int *tab=NULL,
tab est de type int*.
C'est mon choix également, comme dirait notre Marianne.
# En clair, les 2 lignes suivantes effectuent la même opération :
renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
euh... pas de compilo sous la main, mais ca ne devrait pas faire la meme
chose... le deuxieme devrait bien renvoyer l'adresse de 55. le 1er,
plantage : tu demandes d'afficher le contenu de l'adresse 55, celle-ci
ne doit pas etre a toi. int* nU dit au compilo que *n est situé a
l'adresse 55.
Le second renvoie l'adresse de n, &n, c'est trivial.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
ben non : l'adresse de n, comme tu l'as dit juste avant, et comme tu l'a
ecrit la (& signifie adresse de...)
Oui, c'est une valeur affectable à une lvalue de type int*.
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
int *x=&n;
int* x = &n;
(1) : *x est un entier,
non : int*, donc pointeur sur entier.
Ben si, *x désigne un entier, si x est valide.
Je sais, le C/C++ c'est merdique avec les pointeurs, un meme signe
signifie deux choses differentes suivant l'utilisation, faut faire avec :)
Et que dire de & !!!!
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Déjà commenté l'aspect autonome, à mon sens, du C++.
2) Dans mon cours, nous avons détaillé trois étapes fondamentales : la
déclaration, l'allocation mémoire et la désallocation mémoire. Voici ce
que
j'ai compris des 2 premières étapes:
Cours de? surement pas de C++
Non. Tu postes sur un newsgroup de C++, pas de C.
donc utilise vector<int> tab;
Toute la suite est hors de propos en C++ [HS], si ca t'interesse
vraiment de programmer en C il faut aller sur fr.comp.lang.c.
Bon, vais essayer d'y repondre un peu quand meme.
Mais note que tu ne programmes alors absolument pas en C++. en C++, la
gestion de la mémoire, c'est du boulot des classes, alors que la tu
t'embetes avec...
Nous sommes en 2004, il est pertinennt de faire un cours de C++ "from
Relis ton cours de C, et reecris correctement ta ligne de code :
Pourquoi aurait-il un cours de C ? Le C++ est un langage autonome.
int* tab=NULL;
et non
int *tab=NULL,
tab est de type int*.
C'est mon choix également, comme dirait notre Marianne.
# En clair, les 2 lignes suivantes effectuent la même opération :
renvoyer
l'adresse où est stockée la valeur de l'entier 55, c'est bien ça ?
int *nU;
cout << n;
int nU;
cout << &n;
euh... pas de compilo sous la main, mais ca ne devrait pas faire la meme
chose... le deuxieme devrait bien renvoyer l'adresse de 55. le 1er,
plantage : tu demandes d'afficher le contenu de l'adresse 55, celle-ci
ne doit pas etre a toi. int* nU dit au compilo que *n est situé a
l'adresse 55.
Le second renvoie l'adresse de n, &n, c'est trivial.
si on tape :
int nU;
# Quel est le type de &n ? Une chaîne de caractère ?
ben non : l'adresse de n, comme tu l'as dit juste avant, et comme tu l'a
ecrit la (& signifie adresse de...)
Oui, c'est une valeur affectable à une lvalue de type int*.
# Si on voulait l'attribuer à une variable x (qui contiendrait donc
l'adresse de n). Une façon possible serait :
int *x = NULL; (1)
x=&n; (2)
int *x=&n;
int* x = &n;
(1) : *x est un entier,
non : int*, donc pointeur sur entier.
Ben si, *x désigne un entier, si x est valide.
Je sais, le C/C++ c'est merdique avec les pointeurs, un meme signe
signifie deux choses differentes suivant l'utilisation, faut faire avec :)
Et que dire de & !!!!
Réponse d'un newbee pas trop fort en C, donc les autres répondront mieux
:)
Mais franchement, le mec qui enseigne du C++ comme ca, faut qu'il
renomme son cours en "C" tout court... Ne t'embete pas avec ces choses
la si tu fais du C++.
Déjà commenté l'aspect autonome, à mon sens, du C++.
Déjà commenté l'aspect autonome, à mon sens, du C++.
Un prof qui insiste lourdement sur les pointeurs avant de passer à la suite,
ça ne me paraît pas si mal.
Déjà commenté l'aspect autonome, à mon sens, du C++.
Un prof qui insiste lourdement sur les pointeurs avant de passer à la suite,
ça ne me paraît pas si mal.
Déjà commenté l'aspect autonome, à mon sens, du C++.
Un prof qui insiste lourdement sur les pointeurs avant de passer à la suite,
ça ne me paraît pas si mal.