Discussion :

[deubelte]

je sais que c'est qu'une question de notations, mais est il plus logique d'écrire:

Code :

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

double *t;

que

Code :

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

double* t;

car *t signifie que *t est en fait un double et que t point vers un double.

double* n'est pas un type de C++.


En revanche, la notation:

Code :

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

double **tab=new double*[10000];

signifie que *tab est un tableau de pointeurs.
par contre, comment comprendre : double*[10000]

[Cheps]

A mon avis c'est personnel. Moi je préfère:

Code :

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

double* t

J'ai une variable qui s'appelle "t", et son type est "pointeur vers double".

Code :

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

double** tab

J'ai une variable qui s'appelle "tab", et son type est "pointeur vers pointeur vers double".

Code :

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

double* tab[10000]

J'ai un tableau de taille 10000 qui s'appelle "tab", et qui contient des "pointeur vers double".


Dans la pratique, depuis que j'ai découvert les conteneurs de la STL, je me rappel pas d'avoir écrit un programme avec un tableau, sauf quand j'utilise une bibliothèque dont les fonctions prennent des tableaux en paramètre. Dans ce cas je travail avec la STL et convertit en tableau au dernier moment.

Edit: Pour moi *t c'est ça:

Code :

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

1
2
double* t;
*t = 1.0;

Encore une fois, c'est personnel.

[Médinoc]

C'est compliqué, mais il ne faut pas oublier que:

Code C++ :

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

double *a, b;

ne déclare pas b en tant que pointeur sur double, mais en tant que double.
Par contre, ceci le fait:

Code C++ :

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

1
2
typedef double *pdouble;
pdouble a, b;

De nos, jours, j'ai tendance à mette un espace des deux côtés de l'étoile.

[Alp]

je sais que c'est qu'une question de notations, mais est il plus logique d'écrire:

Code :

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

double *t;

que

Code :

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

double* t;

car *t signifie que *t est en fait un double et que t point vers un double.

double* n'est pas un type de C++.

C'est comme ça je le vois en tout cas

En revanche, la notation:

Code :

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

double **tab=new double*[10000];

signifie que *tab est un tableau de pointeurs.
par contre, comment comprendre : double*[10000]

Un tableau de 10 000 pointeurs vers double ?

[deubelte]

bien sur que c'est un tableau de 1000 points, mais ce qui me gène c'est:

Code :

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

new double[1000]

et même plutot l'écriture:

Code :

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

double[1000]

[koala01]

Salut,

Il faut bien comprendre que le pointeur est, quelque part, un "type" en lui-même.

En effet, ca permet de déclarer une variable qui va contenir... l'adresse à laquelle on trouvera (normalement) effectivement la valeur souhaitée.

Ce "type", bien que ce n'en soit pas réellement un, dispose d'une taille précise et connue qui correspond à un nombre de bits suffisant pour représenter l'ensemble des adresses mémoire accessibles.

Que tu place, dans la déclaration d'une variable de type "pointeur vers..." ou de type "pointeur de pointeur vers...", l'étoile (les étoiles) juste à coté du type en question ou juste à coté de l'identifiant de la variable n'a en définitive aucune importance et tient de l'habitude personnelle.

Ce qui importe, c'est que, quand tu déclare une variable sous la forme

Code :

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

double** tab;

tu déclare tab comme étant une variable représentant l'adresse mémoire à laquelle l'ordinateur trouvera(normalement)... l'adresse mémoire où il trouvera un double.

Tu peux donc demander à l'ordinateur d'allouer dynamiquement de la mémoire pour représenter un nombre (sensiblement) quelconque de... pointeurs sur des double, sous la forme de

Code :

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

tab= new double*[X];

Ensuite, tu pourra demander à l'ordinateur d'allouer, pour chaque pointeur sur des double, la mémoire suffisante pour y placer un (autre) nombre (sensiblement) quelconque de double sous la forme de

Code :

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

1
2
3
 
for(int i = 0;i<X;++i)
    tab[i] = new double[Y];

où y représente le nombre, éventuellement calculé, de double dont tu veux disposer de manière contigue

Maintenant, si tu sais très bien qu'il te faudra disposer de X pointeurs vers double, et que ce nombre est "ferme et définitif" (que tu ne devra jamais décider d'en avoir X+1), tu peux demander à ce que l'ordinateur réserve la mémoire suffisante de manière non dynamique, sous la forme de

Code :

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

double *tab[X];

ce qui revient à lui demander de "créer un tableau dans lequel je trouverai X pointeur sur des double contigus en mémoire", tableau que tu pourra ensuite initialiser avec... les adresses auxquels trouver des... tableaux de double sous la forme de

Code :

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

1
2
3
 
for(int i = 0;i<X;++i)
    tab[i] = new double[Y];

[deubelte]

merci pour ta rep

Toujours dans les pointeurs/adresses, quand je lis la valeurs d'un tableau dans la fenetre variable locale, je lis par ex:
0x00284cb0

je sais que c'est de l'hexa, mais si on le transforme en entier normal, cela contient quoi comme information?
est-ce que 0x00284cb1 sera la case suivante?

[Cheps]

merci pour ta rep

Toujours dans les pointeurs/adresses, quand je lis la valeurs d'un tableau dans la fenetre variable locale, je lis par ex:
0x00284cb0

je sais que c'est de l'hexa, mais si on le transforme en entier normal, cela contient quoi comme information?
est-ce que 0x00284cb1 sera la case suivante?

C'est l'adresse en mémoire du pointeur. Dans le cas d'un tableau, les éléments sont stockés dans un espace contigu de la mémoire, donc oui si 0x00284cb0 est la n-ième case alors 0x00284cb1 sera la (n+1)-ième case.

C'est ce qui fait qu'un accès aléatoire dans un tableau a un coût constant, si tu veux le 35ème élément il suffit de rajouter 34 à l'adresse du premier. Il y a une arithmétique des pointeurs qui te permet diverses opérations, intéressant pour travailler sur des tableaux.

[koala01]

C'est l'adresse en mémoire du pointeur. Dans le cas d'un tableau, les éléments sont stockés dans un espace contigu de la mémoire, donc oui si 0x00284cb0 est la n-ième case alors 0x00284cb1 sera la (n+1)-ième case.

A vrai dire, c'est un peu plus compliqué que cela...

L'arithmétique des pointeurs assure que, si tu incrémente un pointeur, selon un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
int main()
{
    int tab[4]; /* tab est un pointeur sur des entiers */
    /* évitons de perdre le pointeur sur le premier élément */
    int *ptrtab=tab;
    ptrtab++;
    /* ...*/
    return 0;
}

tu arrivera à la case contigue à celle qui est pointée par le pointeur qui permet de contenir l'élément en question.

Le problème, c'est que tous les types n'ont pas la même taille...

C'est à dire que tu a de fortes chances de te rendre compte que l'adresse d'un pointeur sur caractères que tu aurait incrémenté soit effectivement l'adresse de départ +1, mais, à coté de cela, si ton pointeur pointe sur... des entiers, et que l'on considère (pour l'exemple) qu'un entier tient sur 4 bytes, l'incrémentation portera l'adresse à... l'adresse de départ +4.

Il ne faut donc pas confondre la "case contigue d'un tableau" avec l'adresse à laquelle cette case contigue peut se trouver

Mais, ceci dit, tu peux être rassuré: quel que soit le type de donnée que tu gère avec un pointeur, le fait d'incrémenter le pointeur t'amenera toujours au début de la variable suivante dans le tableau

[loufoque]

Quand tu déclares une variable comme ceci :

Code :

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

double foo[1000];

Le type de foo est double[1000]; du moins c'est comme celà qu'on le note à part. (si tu veux faire un typedef, il faut utiliser la même syntaxe que pour les déclarations de variables)

Pourquoi alors on écrit pas

Code :

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

double[1000] foo;

C'est tout simplement parce que la syntaxe de C en a décidé autrement. C'est moche, mais c'est comme ça.

À noter qu'il faut pouvoir distinguer les tableaux de pointeurs, double*[1000], des pointeurs vers des tableaux, double(*)[1000] :

Code :

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

1
2
double* foo[1000];
double (*bar)[1000];

Avec ça, tu devrais être convaincu que la syntaxe pour définir des types en C ou C++ est tout simplement horrible.
Quoiqu'on pourrait aussi écrire

Code :

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

1
2
array< pointer<double>, 1000 > foo;
pointer< array<double, 1000> > bar;

Finalement c'est pas si mal...

[Cheps]

Oui koala a raison, je me suis un peu emmêlé les pinceaux. En fait si tu incrémentes ton pointeur (ptr++ ou ptr = ptr+1) tu auras bien le prochain élément, mais l'incrément réel de l'adresse dépend de la taille de l'élément, donc ton adresse sera incrémentée de sizeof(ton type).

[deadalnix]

Et encore, cela dépend de comment ton compilo fait joujou avec les alignements. Mais de base, c'est vrai.

[loufoque]

Non, ça ne dépend pas.
T* ptr; ptr += i; est toujours équivalent à (char*)ptr += i*sizeof(T);

[Médinoc]

(char*)ptr += i*sizeof(T);

Ça compile, ça ?
Peut-être que oui, mais dans tous les cas c'est illisible. Je suis pour restreindre les += aux endroits où la signification est évidente.

Par contre, ça équivaut bel et bien à ptr = (T*)( ((char*)ptr) + i*sizeof(T) ); donc sur le fond ton argument tient parfaitement.

Quant au coup des alignements, on ne le voit jamais sur un pointeur de type simple. Mais pour des structures, c'est le sizeof de la structure qui prend en compte les alignements : par exemple, sizeof (struct { int i, char c }) a de grandes chances d'être égal à 8 et non 5, sur une machine 32 bits.

[Bakura]

Puisque l'on parle de choses très laides ici, je me suis toujours posé une question. Lorsque l'on souhaite passer un tableau de type C de taille fixe par exemple (alors je sais qu'il existe std::tr1::array, mais je trouve son usage vraiment lourd à l'écriture, et puis tant bien même qu'il ne soit pas supporté), on passe le pointeur vers le premier élément. Mais y a t-il une différence au niveau du compilateur de faire ceci :

Code :

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

1
2
3
4
float myTab[4] = {...};
 
MyFunc (myTab);
MyFunc (&myTab[0]);

Le code généré est-il le même ?

[koala01]

Cela risque fort de dépendre des optimisations du compilateur, mais le code

Code :

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

1
2
3
4
5
6
7
8
9
10
void func(float* f)
{
    f[0]=0.0f;
}
void foo()
{
    float f[3];
    func(f);
    func(&f[0]);
}

est, chez moi, transformé, version assembleur, en

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
	.file	"main.cpp"
	.text
.globl __Z4funcPf
	.def	__Z4funcPf;	.scl	2;	.type	32;	.endef
__Z4funcPf:
LFB2:
	pushl	%ebp
LCFI0:
	movl	%esp, %ebp
LCFI1:
	movl	8(%ebp), %edx
	movl	$0x00000000, %eax
	movl	%eax, (%edx)
	leave
	ret
LFE2:
.globl __Z3foov
	.def	__Z3foov;	.scl	2;	.type	32;	.endef
__Z3foov:  /* ce qui suit est la fonction foo() */
LFB3:
	pushl	%ebp
LCFI2:
	movl	%esp, %ebp
LCFI3:
	subl	$16, %esp
LCFI4:
	leal	-12(%ebp), %eax
	pushl	%eax
LCFI5:
	call	__Z4funcPf    /* premier appel de la fonction */
	addl	$4, %esp
	leal	-12(%ebp), %eax
	pushl	%eax
	call	__Z4funcPf  /* deuxieme appel de la fonction */
	addl	$4, %esp
	leave
	ret
LFE3:

Cela semble pour le moins identique, si l'on excepte le fait que l'on quitte foo apres le deuxième appel

[EDIT] ceci dit, seul l'utilisation de &tab[0] est susceptible de fonctionner si tu travaille avec un std::vector (tab.begin() renvoyant un... itérateur (constant ou non, selon le cas)

[Cheps]

Ou alors &(tab.front())

[NiamorH]

De nos, jours, j'ai tendance à mette un espace des deux côtés de l'étoile.

Pareil, et le const entre les deux premiers.

[JolyLoic]

Mais y a t-il une différence au niveau du compilateur de faire ceci :

Code :

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

1
2
3
4
float myTab[4] = {...};
 
MyFunc (myTab);
MyFunc (&myTab[0]);

Le code généré est-il le même ?

Si MyFunc prend en paramètre un float*, probablement. Un pointeur est aisément castable en pointeur sur son premier élément.

Par contre, si par exemple MyFunc est déclaré ainsi (elle pourrait alors se nommer size...) :

Code :

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

1
2
3
4
5
template<size_t N>
size_t MyFunc(float (&array)[N])
{
  return N;
}

Le premier appel retourne 4, le second est illégal.