Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michel Decima
Bonjours,
J'ai un programme super simple :
#include <iostream> #include <map>
void pouet(const int* &) { }
int main(void) { std::map<int*, std::string> po; const int t = 5; const int * p= &t; pouet(p); po.find(p);
return 0; }
qui ne compile pas (ni gcc 4.x, ni gcc 3.x) :
Pour cela ne compile pas sous sa première forme ?
Pour la meme raison que celui-ci, qui ne compile pas non plus:
typedef int* Key;
int main(void) { const int t = 5; const int* p= &t; const Key q = &t; }
Pour la map, la cle est int*, cad pointeur sur int, et tu lui donne un const int*, cad pointeur sur int constant (c'est la valeur pointee qui est const). Cette conversion n'est pas valide.
Ta fonction pouet() et map::find() ne prennent pas leur argument de la meme maniere: Pour pouet, c'est une reference sur un pointeur vers un entier constant, Pour map find c'est une reference constante sur le type clé, qui se trouve etre ici un pointeur vers un entier (non constant).
Pour voir la difference sans difficulté, tu peux ecrire "const" apres le type (const int est equivalent a int const), et lire de droite a gauche. Avec cette convention:
int main(void)
{
std::map<int*, std::string> po;
const int t = 5;
const int * p= &t;
pouet(p);
po.find(p);
return 0;
}
qui ne compile pas (ni gcc 4.x, ni gcc 3.x) :
Pour cela ne compile pas sous sa première forme ?
Pour la meme raison que celui-ci, qui ne compile pas non plus:
typedef int* Key;
int main(void)
{
const int t = 5;
const int* p= &t;
const Key q = &t;
}
Pour la map, la cle est int*, cad pointeur sur int, et tu lui donne un
const int*, cad pointeur sur int constant (c'est la valeur pointee qui
est const). Cette conversion n'est pas valide.
Ta fonction pouet() et map::find() ne prennent pas leur argument
de la meme maniere: Pour pouet, c'est une reference sur un pointeur
vers un entier constant, Pour map find c'est une reference constante sur
le type clé, qui se trouve etre ici un pointeur vers un entier (non
constant).
Pour voir la difference sans difficulté, tu peux ecrire "const" apres
le type (const int est equivalent a int const), et lire de droite a
gauche. Avec cette convention:
int main(void) { std::map<int*, std::string> po; const int t = 5; const int * p= &t; pouet(p); po.find(p);
return 0; }
qui ne compile pas (ni gcc 4.x, ni gcc 3.x) :
Pour cela ne compile pas sous sa première forme ?
Pour la meme raison que celui-ci, qui ne compile pas non plus:
typedef int* Key;
int main(void) { const int t = 5; const int* p= &t; const Key q = &t; }
Pour la map, la cle est int*, cad pointeur sur int, et tu lui donne un const int*, cad pointeur sur int constant (c'est la valeur pointee qui est const). Cette conversion n'est pas valide.
Ta fonction pouet() et map::find() ne prennent pas leur argument de la meme maniere: Pour pouet, c'est une reference sur un pointeur vers un entier constant, Pour map find c'est une reference constante sur le type clé, qui se trouve etre ici un pointeur vers un entier (non constant).
Pour voir la difference sans difficulté, tu peux ecrire "const" apres le type (const int est equivalent a int const), et lire de droite a gauche. Avec cette convention:
Par contre : 1) si je remplace mon int * pour un int cela compile. 2) si je déclare ma map : std::map<int const*, std::string> cela compile.
Pour cela ne compile pas sous sa première forme ?
Parce que les type ne correspondent pas: - dans la map, la clé est 'un pointeur sur un entier' - dans find, le parametre est une référence const sur 'un pointeur sur un entier const'
Michael
Bonjours,
J'ai un programme super simple :
#include <iostream>
#include <map>
void pouet(const int* &)
{
}
int main(void)
{
std::map<int*, std::string> po;
const int t = 5;
const int * p= &t;
pouet(p);
po.find(p);
Par contre :
1) si je remplace mon int * pour un int cela compile.
2) si je déclare ma map : std::map<int const*, std::string> cela
compile.
Pour cela ne compile pas sous sa première forme ?
Parce que les type ne correspondent pas:
- dans la map, la clé est 'un pointeur sur un entier'
- dans find, le parametre est une référence const sur 'un pointeur
sur un entier const'
Par contre : 1) si je remplace mon int * pour un int cela compile. 2) si je déclare ma map : std::map<int const*, std::string> cela compile.
Pour cela ne compile pas sous sa première forme ?
Parce que les type ne correspondent pas: - dans la map, la clé est 'un pointeur sur un entier' - dans find, le parametre est une référence const sur 'un pointeur sur un entier const'