Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Développement Développement Langage C++ map et operateur []

map et operateur []

58 réponses
Avatar
Fanny Chevalier
Bonjour,

Voila, j'ai fait une map :
map <CoupleInt, double>myMap;
destinée a accueillir une valeur relative a un couple d'entiers
CoupleInt dont la syntaxe de classe est la suivante :

class CoupleInt
{
public:
CoupleInt();
CoupleInt(int, int);
CoupleInt(const CoupleInt&);
~CoupleInt();

private:
int first;
int second;
};

Lorsque je fais l'appel (par exemple)
double myDoubleValue = 3.02;
CoupleInt couple = CoupleInt(3,2);
myMap[couple] = myDoubleValue;

il n'a pas l'air d'aimer myMap[couple].

Une idée?

Merci pour votre aide
Fanny
Signaler un problème avec ce contenu

10 réponses

Supprimer
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
1 2 3 4 5
Avatar
Andre Heinen
On 09 Oct 2004 12:38:23 +0200, James Kanze
wrote:

Andre Heinen writes:
|> N'est-ce pas pareil? Quelle est la différence entre
|> CoupleInt couple( int(3), int(2) );
|> et
|> CoupleInt couple(3, 2);
|> ?

Attention ! Avec des constantes, il n'y a aucune différence. Mais si tu
écris :
CoupleInt couple( int(i), int(j) ) ;
tu as déclaré une fonction (implicitement externe), et non défini une
variable.


Je trouve ça très difficile à admettre.

CoupleInt couple(int, int);
est une déclaration de fonction parce qu'int est un type.

CoupleInt couple(2, 3);
est une définition de variable parce que 2 et 3 ne sont pas des
types mais des valeurs.

CoupleInt couple(int(2), int(3));
est toujours une définition de variable, parce que int(2) et
int(3) sont des valeurs (des temporaires).

Si maintenant j'écris
int i=2, j=3;
CoupleInt couple(int(i), int(j));
int(i) et int(j) sont toujours des valeurs (des temporaires), et
donc je ne comprends pas qu'il ne s'agisse pas d'une définition
de variable.
Veux-tu dire que le compilateur comprend la ligne ci-dessus comme
CoupleInt couple(int i, int j);
?

Je crois que la plupart des gens considère ça plutôt un boggue qu'un
feature du langage.


Je comprends ça très bien... ;-)

--
Andre Heinen
My address, rot13-encoded: n qbg urvara ng rhebcrnayvax qbg pbz

Avatar
Jean-Marc Bourguet
Andre Heinen writes:

Si maintenant j'écris
int i=2, j=3;
CoupleInt couple(int(i), int(j));
int(i) et int(j) sont toujours des valeurs (des temporaires), et
donc je ne comprends pas qu'il ne s'agisse pas d'une définition
de variable.
Veux-tu dire que le compilateur comprend la ligne ci-dessus comme
CoupleInt couple(int i, int j);
?


Oui. Il est des circonstances ou les parentheses sont utiles, et
c'est difficile de les interdire quand elles sont redondates.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

Avatar
Andre Heinen
On Mon, 11 Oct 2004 14:54:05 +0200, Fabien LE LEZ
wrote:

On Mon, 11 Oct 2004 13:46:44 +0200, Andre Heinen
:

J'ai déjà eu quelques occasions de l'utiliser.


Dans quel(s) cas ?


Lorsqu'une fonction retourne non pas une valeur, mais deux (ou
plusieurs).

Une première solution est évidemment de passer par référence les
variables qui doivent recevoir les valeurs à retourner.
J'utilise souvent cette possibilité, mais pas toujours, car
parfois le code ne serait pas clair. Par exemple, il peut être
difficile de trouver un nom de fonction qui indique sans
ambiguïté que la fonction modifie les arguments.

Une autre possibilité est de retourner une instance de classe qui
englobe toutes les données à retourner. Mais parfois, lorsque le
besoin est très local, il n'est pas justifié de passer du temps à
créer une classe avec une interface soignée.

L'alternative est de retourner une struct (sans fonctions
membres, et avec toutes les données publiques). Si je ne dois
retourner que deux valeurs, je n'ai pas besoin de créer la struct
moi-même: std::pair est là pour ça.

Voilà voilà...

--
Andre Heinen
My address, rot13-encoded: n qbg urvara ng rhebcrnayvax qbg pbz


Avatar
Fabien LE LEZ
On Mon, 11 Oct 2004 16:43:35 +0200, Andre Heinen
:

[Utilisation de std::pair<>]

Lorsqu'une fonction retourne non pas une valeur, mais deux


Ce mécanisme est très agréable à utiliser en PHP :

list ($prix, $couleur)= CalculeCouleurEtPrix();

Par contre, en C++, ça me paraît plus pénible. Surtout avec
std::pair<>, où les membres sont anonymes.


Par exemple, il peut être
difficile de trouver un nom de fonction qui indique sans
ambiguïté que la fonction modifie les arguments.


Dans mon code, une fonction qui prend un argument par référence non
constante indique sans ambiguïté que l'argument sera modifié. Mais
c'est vrai que ce n'est pas visible dans le code qui appelle la
fonction.



--
;-)

Avatar
Alexandre
Petit détail de vocabulaire : le mot "struct" déclare/définit une
classe. Il n'y a pas de structures en C++.

Mais j'imagine que tu voulais parler d'une classe où tous les membres
sont publics.


c'est ça . ça évite d'avoir à taper "public:" ;-)

Ben... franchement, je n'ai encore jamais eu l'occasion d'utiliser
std::pair<>. Je me demande même si cette classe n'a pas été créée
uniquement comme helper pour std::map<>.


sans doute ;-)



--
;-)


Avatar
Alexandre
"Fabien LE LEZ" a écrit dans le message de news:

On 09 Oct 2004 12:38:23 +0200, James Kanze :

Je crois que la plupart des gens considère ça plutôt un boggue


Yep. D'ailleurs, je trouve qu'un bon compilo devrait balancer un
warning dès qu'on déclare une fonction à l'intérieur du corps d'une
autre fonction.


AMA il devrait même balancer une erreur ;-)


Avatar
Fabien LE LEZ
On Mon, 11 Oct 2004 20:39:42 +0200, "Alexandre"
:

AMA il devrait même balancer une erreur ;-)


Ben non : les messages d'erreurs sont définis par la norme, tandis que
les warnings sont laissés au choix de l'éditeur.


--
;-)

Avatar
James Kanze
Andre Heinen writes:

|> On 09 Oct 2004 12:38:23 +0200, James Kanze
|> wrote:

|> >Andre Heinen writes:
|> >|> N'est-ce pas pareil? Quelle est la différence entre
|> >|> CoupleInt couple( int(3), int(2) );
|> >|> et
|> >|> CoupleInt couple(3, 2);
|> >|> ?

|> >Attention ! Avec des constantes, il n'y a aucune différence. Mais
|> >si tu écris :
|> > CoupleInt couple( int(i), int(j) ) ;
|> >tu as déclaré une fonction (implicitement externe), et non défini
|> >une variable.

|> Je trouve ça très difficile à admettre.

C'est pourtant comme ça.

|> CoupleInt couple(int, int);
|> est une déclaration de fonction parce qu'int est un type.

Tout à fait.

|> CoupleInt couple(2, 3);
|> est une définition de variable parce que 2 et 3 ne sont pas des
|> types mais des valeurs.

Aussi.

|> CoupleInt couple(int(2), int(3));
|> est toujours une définition de variable, parce que int(2) et
|> int(3) sont des valeurs (des temporaires).

Surtout, la suite de tokens « int ( 2 ) » ne peut pas être interprétée
autrement que comme une expression de valeur.

|> Si maintenant j'écris
|> int i=2, j=3;
|> CoupleInt couple(int(i), int(j));

|> int(i) et int(j) sont toujours des valeurs (des temporaires), et
|> donc je ne comprends pas qu'il ne s'agisse pas d'une définition de
|> variable.

Le problème, c'est que la suite de tokens « int ( i ) » peut être
interprété soit comme une valeur, soit come une déclaration d'une
variable i (variable qui pourrait, lui, être le paramètre d'une
fonction). Et la norme dit que chaque fois qu'il y a ambigüité, et que
les deux sont légaux, c'est la declaration qui prime. Donc, dans la
declaration ci-dessus, « int ( i ) » declare bien un paramètre de
fonction de type int, et de nom (formel) i.

|> Veux-tu dire que le compilateur comprend la ligne ci-dessus comme
|> CoupleInt couple(int i, int j);
|> ?

Tout à fait. Les parenthèses ne sont pas nécessaires, mais ils sont
permis.

--
James Kanze
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Avatar
James Kanze
"Alexandre" writes:

|> "Fabien LE LEZ" a écrit dans le message de
|> news:
|> > On 09 Oct 2004 12:38:23 +0200, James Kanze :

|> > >Je crois que la plupart des gens considère ça plutôt un boggue

|> > Yep. D'ailleurs, je trouve qu'un bon compilo devrait balancer un
|> > warning dès qu'on déclare une fonction à l'intérieur du corps
|> > d'une autre fonction.

|> AMA il devrait même balancer une erreur ;-)

Le problème, c'est l'histoire. Aujourd'hui, il ne vient à l'esprit de
personne de déclarer une fonction à l'intérieur d'une autre fonction. Il
y a vingt ans, en révanche, en C...

--
James Kanze
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Avatar
Vincent Lascaux
Le problème, c'est que la suite de tokens « int ( i ) » peut être
interprété soit comme une valeur, soit come une déclaration d'une
variable i (variable qui pourrait, lui, être le paramètre d'une
fonction). Et la norme dit que chaque fois qu'il y a ambigüité, et que
les deux sont légaux, c'est la declaration qui prime.


Est ce que tu sais ce qui a poussé le choix dans ce sens ?
Si on avait décidé qu'à chaque fois qu'il y a ambigüité, c'est l'appel de
fonction qui prime, on aurait pas perdu en richesse de langage (puisqu'on
peut par exemple définir la fonction en changeant le nom des arguments,
voire en les supprimant (les noms, pas les arguments)). Il me semble que ca
aurait été plus simple pour tout le monde...

--
Vincent

1 2 3 4 5