imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur
[] pour acc=E9der =E0 un =E9l=E9ment inexistant:
std::map<int,int> m;
std::cout << m[0];
Que se passe-t-il alors? Est-on garanti qu'un nouvel entier acc=E9d=E9 de
cette mani=E8re soit toujours initialis=E9 =E0 0? Et comment est-ce
possible?
imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur [] pour accéder à un élément inexistant:
std::map<int,int> m; std::cout << m[0];
Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de cette manière soit toujours initialisé à 0? Et comment est-ce possible?
Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe pas dans la map. C'est le constructeur par défaut qui est appelé. Donc c'est autant garanti que : int x = int( ); // x=0.
-- -Stan
On 29 jan, 11:28, Guillaume <g.gour...@gmail.com> wrote:
Bonjour à tous,
imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur
[] pour accéder à un élément inexistant:
std::map<int,int> m;
std::cout << m[0];
Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de
cette manière soit toujours initialisé à 0? Et comment est-ce
possible?
Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe
pas
dans la map. C'est le constructeur par défaut qui est appelé.
Donc c'est autant garanti que : int x = int( ); // x=0.
imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur [] pour accéder à un élément inexistant:
std::map<int,int> m; std::cout << m[0];
Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de cette manière soit toujours initialisé à 0? Et comment est-ce possible?
Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe pas dans la map. C'est le constructeur par défaut qui est appelé. Donc c'est autant garanti que : int x = int( ); // x=0.
-- -Stan
Guillaume
On 29 jan, 12:08, Stan wrote:
On 29 jan, 11:28, Guillaume wrote:
> Bonjour à tous,
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > [] pour accéder à un élément inexistant:
> std::map<int,int> m; > std::cout << m[0];
> Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de > cette manière soit toujours initialisé à 0? Et comment est-ce > possible?
> Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe pas dans la map. C'est le constructeur par défaut qui est appelé. Donc c'est autant garanti que : int x = int( ); // x=0.
-- -Stan
Je ne savais pas que les types primitifs avaient des constructeurs par défaut... Même bool?
G.
On 29 jan, 12:08, Stan <t...@neuf.fr> wrote:
On 29 jan, 11:28, Guillaume <g.gour...@gmail.com> wrote:
> Bonjour à tous,
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur
> [] pour accéder à un élément inexistant:
> std::map<int,int> m;
> std::cout << m[0];
> Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de
> cette manière soit toujours initialisé à 0? Et comment est-ce
> possible?
> Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe
pas
dans la map. C'est le constructeur par défaut qui est appelé.
Donc c'est autant garanti que : int x = int( ); // x=0.
--
-Stan
Je ne savais pas que les types primitifs avaient des constructeurs par
défaut... Même bool?
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > [] pour accéder à un élément inexistant:
> std::map<int,int> m; > std::cout << m[0];
> Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de > cette manière soit toujours initialisé à 0? Et comment est-ce > possible?
> Merci pour vos lumières!
l'operateur [] renvoie un objet de type T() quand l'élément n'existe pas dans la map. C'est le constructeur par défaut qui est appelé. Donc c'est autant garanti que : int x = int( ); // x=0.
-- -Stan
Je ne savais pas que les types primitifs avaient des constructeurs par défaut... Même bool?
G.
Stan
On 29 jan, 13:14, Guillaume wrote:
On 29 jan, 12:08, Stan wrote:
> On 29 jan, 11:28, Guillaume wrote:
> > Bonjour à tous,
> > imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > > [] pour accéder à un élément inexistant:
> > std::map<int,int> m; > > std::cout << m[0];
> > Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accéd é de > > cette manière soit toujours initialisé à 0? Et comment est-ce > > possible?
> > Merci pour vos lumières!
> l'operateur [] renvoie un objet de type T() quand l'élément n'exist e > pas > dans la map. C'est le constructeur par défaut qui est appelé. > Donc c'est autant garanti que : int x = int( ); // x=0.
> -- > -Stan
Je ne savais pas que les types primitifs avaient des constructeurs par défaut... Même bool?
G.
A strictement parler, le constructeur ne s'applique qu'aux class et struct; c'est comme cela que c'est défini dans la norme me semble-t-il. Mais Stroustrup emploie cette teminogie pour les types built-in. ( cf The C++ Programming Language 3rd § 10.4.2 page 224 ).
Donc idem pour un bool.
-- -Stan
On 29 jan, 13:14, Guillaume <g.gour...@gmail.com> wrote:
On 29 jan, 12:08, Stan <t...@neuf.fr> wrote:
> On 29 jan, 11:28, Guillaume <g.gour...@gmail.com> wrote:
> > Bonjour à tous,
> > imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur
> > [] pour accéder à un élément inexistant:
> > std::map<int,int> m;
> > std::cout << m[0];
> > Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accéd é de
> > cette manière soit toujours initialisé à 0? Et comment est-ce
> > possible?
> > Merci pour vos lumières!
> l'operateur [] renvoie un objet de type T() quand l'élément n'exist e
> pas
> dans la map. C'est le constructeur par défaut qui est appelé.
> Donc c'est autant garanti que : int x = int( ); // x=0.
> --
> -Stan
Je ne savais pas que les types primitifs avaient des constructeurs par
défaut... Même bool?
G.
A strictement parler, le constructeur ne s'applique qu'aux class et
struct;
c'est comme cela que c'est défini dans la norme me semble-t-il.
Mais Stroustrup emploie cette teminogie pour les types built-in.
( cf The C++ Programming Language 3rd § 10.4.2 page 224 ).
> > imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > > [] pour accéder à un élément inexistant:
> > std::map<int,int> m; > > std::cout << m[0];
> > Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accéd é de > > cette manière soit toujours initialisé à 0? Et comment est-ce > > possible?
> > Merci pour vos lumières!
> l'operateur [] renvoie un objet de type T() quand l'élément n'exist e > pas > dans la map. C'est le constructeur par défaut qui est appelé. > Donc c'est autant garanti que : int x = int( ); // x=0.
> -- > -Stan
Je ne savais pas que les types primitifs avaient des constructeurs par défaut... Même bool?
G.
A strictement parler, le constructeur ne s'applique qu'aux class et struct; c'est comme cela que c'est défini dans la norme me semble-t-il. Mais Stroustrup emploie cette teminogie pour les types built-in. ( cf The C++ Programming Language 3rd § 10.4.2 page 224 ).
Donc idem pour un bool.
-- -Stan
Fabien LE LEZ
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume :
Je ne savais pas que les types primitifs avaient des constructeurs par défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne sont pas systématiquement appelés.
int() renvoie 0
int x; // valeur indéterminée
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume
<g.gourdin@gmail.com>:
Je ne savais pas que les types primitifs avaient des constructeurs par
défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne
sont pas systématiquement appelés.
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume :
Je ne savais pas que les types primitifs avaient des constructeurs par défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne sont pas systématiquement appelés.
int() renvoie 0
int x; // valeur indéterminée
Guillaume
On 29 jan, 14:01, Fabien LE LEZ wrote:
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume :
>Je ne savais pas que les types primitifs avaient des constructeurs par >défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne sont pas systématiquement appelés.
int() renvoie 0
int x; // valeur indéterminée
Je suis curieux à propos de cette fonctions int(). S'agit-il d'une fonction au sens classique du terme? Ou bien a-t-on le droit d'écrire: int x(); // x = 0
On 29 jan, 14:01, Fabien LE LEZ <grams...@gramster.com> wrote:
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume
<g.gour...@gmail.com>:
>Je ne savais pas que les types primitifs avaient des constructeurs par
>défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne
sont pas systématiquement appelés.
int() renvoie 0
int x; // valeur indéterminée
Je suis curieux à propos de cette fonctions int(). S'agit-il d'une
fonction au sens classique du terme? Ou bien a-t-on le droit d'écrire:
int x(); // x = 0
On Fri, 29 Jan 2010 04:14:53 -0800 (PST), Guillaume :
>Je ne savais pas que les types primitifs avaient des constructeurs par >défaut...
Ce ne sont pas à proprement parler des constructeurs, puisqu'ils ne sont pas systématiquement appelés.
int() renvoie 0
int x; // valeur indéterminée
Je suis curieux à propos de cette fonctions int(). S'agit-il d'une fonction au sens classique du terme? Ou bien a-t-on le droit d'écrire: int x(); // x = 0
Jean-Marc Bourguet
Guillaume writes:
int x(); // x = 0
Declaration d'une fonction nommee x retournant un int...
-- 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
Guillaume <g.gourdin@gmail.com> writes:
int x(); // x = 0
Declaration d'une fonction nommee x retournant un int...
--
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
Declaration d'une fonction nommee x retournant un int...
-- 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
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > [] pour accéder à un élément inexistant: > > std::map<int,int> m; > std::cout << m[0]; > > Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de > cette manière soit toujours initialisé à 0? Et comment est-ce > possible?
Les autres messages te donnent la réponse. J'ajoute que si tu as une map<K,V> et que tu utilises [], alors V doit avoir un constructeur par défaut. Si c'est génant, tu peux utiliser at() au lieu de operator[]. at() déclenche une exception plutôt que d'insérer en silence lorsque tu accèdes à un élément inexistant. Je ne sais pas si c'est standard (j'espère parce que je n'utilise que ça).
Ou je suis encore plus fatigue que je le pense, ou ce n'est pas standard.
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
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur
> [] pour accéder à un élément inexistant:
>
> std::map<int,int> m;
> std::cout << m[0];
>
> Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de
> cette manière soit toujours initialisé à 0? Et comment est-ce
> possible?
Les autres messages te donnent la réponse. J'ajoute que si tu as une
map<K,V> et que tu utilises [], alors V doit avoir un constructeur par
défaut. Si c'est génant, tu peux utiliser at() au lieu de operator[].
at() déclenche une exception plutôt que d'insérer en silence lorsque
tu accèdes à un élément inexistant. Je ne sais pas si c'est standard
(j'espère parce que je n'utilise que ça).
Ou je suis encore plus fatigue que je le pense, ou ce n'est pas standard.
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
> imaginons que j'ai un std::map<int,int>, et que j'utilise l'operateur > [] pour accéder à un élément inexistant: > > std::map<int,int> m; > std::cout << m[0]; > > Que se passe-t-il alors? Est-on garanti qu'un nouvel entier accédé de > cette manière soit toujours initialisé à 0? Et comment est-ce > possible?
Les autres messages te donnent la réponse. J'ajoute que si tu as une map<K,V> et que tu utilises [], alors V doit avoir un constructeur par défaut. Si c'est génant, tu peux utiliser at() au lieu de operator[]. at() déclenche une exception plutôt que d'insérer en silence lorsque tu accèdes à un élément inexistant. Je ne sais pas si c'est standard (j'espère parce que je n'utilise que ça).
Ou je suis encore plus fatigue que je le pense, ou ce n'est pas standard.
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
Guillaume
On 29 jan, 14:32, Jean-Marc Bourguet wrote:
Guillaume writes: > int x(); // x = 0
Declaration d'une fonction nommee x retournant un int...
Si tu préféres:
void foo() { int x(); }
On 29 jan, 14:32, Jean-Marc Bourguet <j...@bourguet.org> wrote:
Guillaume <g.gour...@gmail.com> writes:
> int x(); // x = 0
Declaration d'une fonction nommee x retournant un int...
Declaration d'une fonction nommee x retournant un int...
Si tu préféres:
void foo() { int x(); }
Jean-Marc Bourguet
Guillaume writes:
On 29 jan, 14:32, Jean-Marc Bourguet wrote: > Guillaume writes: > > int x(); // x = 0 > > Declaration d'une fonction nommee x retournant un int...
Si tu préféres:
void foo() { int x(); }
Ca ne change rien. Le fait que ca surprend dans ce contexte est souvent appele le "most vexing parse".
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
Guillaume <g.gourdin@gmail.com> writes:
On 29 jan, 14:32, Jean-Marc Bourguet <j...@bourguet.org> wrote:
> Guillaume <g.gour...@gmail.com> writes:
> > int x(); // x = 0
>
> Declaration d'une fonction nommee x retournant un int...
Si tu préféres:
void foo()
{
int x();
}
Ca ne change rien. Le fait que ca surprend dans ce contexte est souvent
appele le "most vexing parse".
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
On 29 jan, 14:32, Jean-Marc Bourguet wrote: > Guillaume writes: > > int x(); // x = 0 > > Declaration d'une fonction nommee x retournant un int...
Si tu préféres:
void foo() { int x(); }
Ca ne change rien. Le fait que ca surprend dans ce contexte est souvent appele le "most vexing parse".
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
