Bonjour, je viens de lire dans un ancien fil (sur comp.lang.c++.moderated)
que les références n'existent pas à l'exécution (runtime) mais seulement au
moment de la compilation (compile time).
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut
pas y avoir de tableaux de références.
Bon, si c'est faux dites le moi.
Alors, si on peut pas avoir de tableau de références on est donc obligé
d'avoir des tableaux de pointeurs.
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
Juste ou pas ?
Il me semble que oui
Quelle autre alternative ?
- des tableaux d'objets ;-) - des tableaux de pointeurs intelligents (si le tableau a la charge de détruire les objets pointés) - des tableaux d'itérateurs (par exemple, si tu fais un tableau de pointeurs vers des éléments d'un std::list<>)
On 17 Oct 2003 11:45:56 GMT, Zouplaz <pouet@pouet.com> wrote:
Alors, si on peut pas avoir de tableau de références on est donc obligé
d'avoir des tableaux de pointeurs.
Juste ou pas ?
Il me semble que oui
Quelle autre alternative ?
- des tableaux d'objets ;-)
- des tableaux de pointeurs intelligents (si le tableau a la charge de
détruire les objets pointés)
- des tableaux d'itérateurs (par exemple, si tu fais un tableau de
pointeurs vers des éléments d'un std::list<>)
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
Juste ou pas ?
Il me semble que oui
Quelle autre alternative ?
- des tableaux d'objets ;-) - des tableaux de pointeurs intelligents (si le tableau a la charge de détruire les objets pointés) - des tableaux d'itérateurs (par exemple, si tu fais un tableau de pointeurs vers des éléments d'un std::list<>)
On Fri, 17 Oct 2003 17:53:21 +0200, Fabien LE LEZ wrote:
- des tableaux d'itérateurs (par exemple, si tu fais un tableau de pointeurs vers des éléments d'un std::list<>)
Dans le même ordre d'idée : si tu veux un tableau de pointeurs sur des éléments d'un std::vector<>, tu peux tout simplement stocker les index des éléments concernés.
On Fri, 17 Oct 2003 17:53:21 +0200, Fabien LE LEZ
<gramster@gramster.com> wrote:
- des tableaux d'itérateurs (par exemple, si tu fais un tableau de
pointeurs vers des éléments d'un std::list<>)
Dans le même ordre d'idée : si tu veux un tableau de pointeurs sur des
éléments d'un std::vector<>, tu peux tout simplement stocker les index
des éléments concernés.
On Fri, 17 Oct 2003 17:53:21 +0200, Fabien LE LEZ wrote:
- des tableaux d'itérateurs (par exemple, si tu fais un tableau de pointeurs vers des éléments d'un std::list<>)
Dans le même ordre d'idée : si tu veux un tableau de pointeurs sur des éléments d'un std::vector<>, tu peux tout simplement stocker les index des éléments concernés.
Bonjour, je viens de lire dans un ancien fil (sur comp.lang.c++.moderated) que les références n'existent pas à l'exécution (runtime) mais seulement au moment de la compilation (compile time).
Oui et non. Ce qui est certain, c'est que les références ne sont pas des objets, qu'elles n'ont pas d'adresse ni de taille, ni même réelement une valeur -- une fois initialisée, une référence comporte exactement comme l'objet qui lui a servi à l'initialisation.
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
La raison principale qu'on ne peut pas avoir de tableaux de référence, c'est qu'une référence n'a pas de taille ni d'adresse. Et qu'en C++, l'indexation des tableaux passe par une calcule des adresses se servant de la taille.
Bon, si c'est faux dites le moi.
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
Juste ou pas ? Quelle autre alternative ?
Pas tant que ça.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Zouplaz <pouet@pouet.com> wrote in message
news:<Xns94178C8745C93Zoupla@213.228.0.196>...
Bonjour, je viens de lire dans un ancien fil (sur
comp.lang.c++.moderated) que les références n'existent pas à
l'exécution (runtime) mais seulement au moment de la compilation
(compile time).
Oui et non. Ce qui est certain, c'est que les références ne sont pas des
objets, qu'elles n'ont pas d'adresse ni de taille, ni même réelement une
valeur -- une fois initialisée, une référence comporte exactement comme
l'objet qui lui a servi à l'initialisation.
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne
peut pas y avoir de tableaux de références.
La raison principale qu'on ne peut pas avoir de tableaux de référence,
c'est qu'une référence n'a pas de taille ni d'adresse. Et qu'en C++,
l'indexation des tableaux passe par une calcule des adresses se servant
de la taille.
Bon, si c'est faux dites le moi.
Alors, si on peut pas avoir de tableau de références on est donc
obligé d'avoir des tableaux de pointeurs.
Juste ou pas ? Quelle autre alternative ?
Pas tant que ça.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Bonjour, je viens de lire dans un ancien fil (sur comp.lang.c++.moderated) que les références n'existent pas à l'exécution (runtime) mais seulement au moment de la compilation (compile time).
Oui et non. Ce qui est certain, c'est que les références ne sont pas des objets, qu'elles n'ont pas d'adresse ni de taille, ni même réelement une valeur -- une fois initialisée, une référence comporte exactement comme l'objet qui lui a servi à l'initialisation.
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
La raison principale qu'on ne peut pas avoir de tableaux de référence, c'est qu'une référence n'a pas de taille ni d'adresse. Et qu'en C++, l'indexation des tableaux passe par une calcule des adresses se servant de la taille.
Bon, si c'est faux dites le moi.
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
Juste ou pas ? Quelle autre alternative ?
Pas tant que ça.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Jean-Marc Molina
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler ! C'est tout l'intérêt des références comparées aux pointeurs, une référence ne peut être NULL. Elles permettent d'empêcher de nombreux bogues (quand on oublie les ASSERT sur ses pointeurs ou d'initiliaser un pointeur à NULL). Par contre pas de polymorphisme avec les références. Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...) que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références. On ne s'en sert pas toujours mais quand j'ai du résoudre un problème... J'ai été confronté à cette dure mais très logique réalité.
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
En effet, ça reste la solution la plus souple et la plus efficace. Le mieux c'est encore d'utiliser des smart pointers et STL, disponibles dans des bibliothèques C++ comme Boost, ma favorite.
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut
pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler !
C'est tout l'intérêt des références comparées aux pointeurs, une référence
ne peut être NULL.
Elles permettent d'empêcher de nombreux bogues (quand on oublie les ASSERT
sur ses pointeurs ou d'initiliaser un pointeur à NULL).
Par contre pas de polymorphisme avec les références. Il y a quelques années
j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer
des listes...) que j'avais oublié cette différence fondamentale, pas de
polymorphisme pour les références. On ne s'en sert pas toujours mais quand
j'ai du résoudre un problème... J'ai été confronté à cette dure mais très
logique réalité.
Alors, si on peut pas avoir de tableau de références on est donc obligé
d'avoir des tableaux de pointeurs.
En effet, ça reste la solution la plus souple et la plus efficace.
Le mieux c'est encore d'utiliser des smart pointers et STL, disponibles dans
des bibliothèques C++ comme Boost, ma favorite.
JM
--
Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler ! C'est tout l'intérêt des références comparées aux pointeurs, une référence ne peut être NULL. Elles permettent d'empêcher de nombreux bogues (quand on oublie les ASSERT sur ses pointeurs ou d'initiliaser un pointeur à NULL). Par contre pas de polymorphisme avec les références. Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...) que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références. On ne s'en sert pas toujours mais quand j'ai du résoudre un problème... J'ai été confronté à cette dure mais très logique réalité.
Alors, si on peut pas avoir de tableau de références on est donc obligé d'avoir des tableaux de pointeurs.
En effet, ça reste la solution la plus souple et la plus efficace. Le mieux c'est encore d'utiliser des smart pointers et STL, disponibles dans des bibliothèques C++ comme Boost, ma favorite.
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Christophe Lephay
Jean-Marc Molina wrote:
Par contre pas de polymorphisme avec les références. Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...) que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références. On ne s'en sert pas toujours mais quand j'ai du résoudre un problème... J'ai été confronté à cette dure mais très logique réalité.
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les références" ?
Chris
Jean-Marc Molina wrote:
Par contre pas de polymorphisme avec les références. Il y a quelques
années j'avais tellement pris l'habitude d'utiliser des références
(STL pour gérer des listes...) que j'avais oublié cette différence
fondamentale, pas de polymorphisme pour les références. On ne s'en
sert pas toujours mais quand j'ai du résoudre un problème... J'ai été
confronté à cette dure mais très logique réalité.
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les
références" ?
Par contre pas de polymorphisme avec les références. Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...) que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références. On ne s'en sert pas toujours mais quand j'ai du résoudre un problème... J'ai été confronté à cette dure mais très logique réalité.
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les références" ?
Chris
kanze
"Jean-Marc Molina" wrote in message news:<bn2shp$msp$...
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler ! C'est tout l'intérêt des références comparées aux pointeurs, une référence ne peut être NULL.
C'est la convention, oui. Un essai de créer une référence nulle donne un comportement indéfini.
Elles permettent d'empêcher de nombreux bogues (quand on oublie les ASSERT sur ses pointeurs ou d'initiliaser un pointeur à NULL).
La possibilité des bogues y est toujours. Du genre :
int* pi = NULL ; int& ri = *pi ;
En gros, avec les références, la responsibilité de s'assurer que ce n'est pas nulle, c'est chez celui qui initialise la référence. Avec les pointeurs, c'est chez celui qui l'utilise.
Par contre pas de polymorphisme avec les références.
Dans quel langage. Ça marche très bien en C++.
Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...)
La STL (de même que toutes les autres collections que je connais) ne permet pas de collections de référence.
que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références.
Je crois que tu te gourres. La STL travaille avec des valeurs, et il n'y a pas de polymorphisme pour les valeurs.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Jean-Marc Molina" <goa_pasdepourriel_@ifrance.com> wrote in message
news:<bn2shp$msp$1@news-reader3.wanadoo.fr>...
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne
peut pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler !
C'est tout l'intérêt des références comparées aux pointeurs, une
référence ne peut être NULL.
C'est la convention, oui. Un essai de créer une référence nulle donne un
comportement indéfini.
Elles permettent d'empêcher de nombreux bogues (quand on oublie les
ASSERT sur ses pointeurs ou d'initiliaser un pointeur à NULL).
La possibilité des bogues y est toujours. Du genre :
int* pi = NULL ;
int& ri = *pi ;
En gros, avec les références, la responsibilité de s'assurer que ce
n'est pas nulle, c'est chez celui qui initialise la référence. Avec les
pointeurs, c'est chez celui qui l'utilise.
Par contre pas de polymorphisme avec les références.
Dans quel langage. Ça marche très bien en C++.
Il y a quelques années j'avais tellement pris l'habitude d'utiliser
des références (STL pour gérer des listes...)
La STL (de même que toutes les autres collections que je connais) ne
permet pas de collections de référence.
que j'avais oublié cette différence fondamentale, pas de polymorphisme
pour les références.
Je crois que tu te gourres. La STL travaille avec des valeurs, et il n'y
a pas de polymorphisme pour les valeurs.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Jean-Marc Molina" wrote in message news:<bn2shp$msp$...
J'avais jamais vu les choses comme ça, et ça explique pourquoi il ne peut pas y avoir de tableaux de références.
Je pense que oui mais il te faut l'initaliser avant de compiler ! C'est tout l'intérêt des références comparées aux pointeurs, une référence ne peut être NULL.
C'est la convention, oui. Un essai de créer une référence nulle donne un comportement indéfini.
Elles permettent d'empêcher de nombreux bogues (quand on oublie les ASSERT sur ses pointeurs ou d'initiliaser un pointeur à NULL).
La possibilité des bogues y est toujours. Du genre :
int* pi = NULL ; int& ri = *pi ;
En gros, avec les références, la responsibilité de s'assurer que ce n'est pas nulle, c'est chez celui qui initialise la référence. Avec les pointeurs, c'est chez celui qui l'utilise.
Par contre pas de polymorphisme avec les références.
Dans quel langage. Ça marche très bien en C++.
Il y a quelques années j'avais tellement pris l'habitude d'utiliser des références (STL pour gérer des listes...)
La STL (de même que toutes les autres collections que je connais) ne permet pas de collections de référence.
que j'avais oublié cette différence fondamentale, pas de polymorphisme pour les références.
Je crois que tu te gourres. La STL travaille avec des valeurs, et il n'y a pas de polymorphisme pour les valeurs.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Jean-Marc Molina
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les références" ?
Je voulais parler de mon problème. On peut bien entendu (après vérification je n'étais pas sûr :p) écrire : fille f; mere & m = f;
Comme on peut écrire : mere * m = new fille;
Par contre je n'ai jamais eu besoin d'utiliser des références pour du polymorphisme, j'ai toujours recourt aux pointeurs. Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout ça avec des références.
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les
références" ?
Je voulais parler de mon problème.
On peut bien entendu (après vérification je n'étais pas sûr :p) écrire :
fille f;
mere & m = f;
Comme on peut écrire :
mere * m = new fille;
Par contre je n'ai jamais eu besoin d'utiliser des références pour du
polymorphisme, j'ai toujours recourt aux pointeurs.
Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes),
IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors
je ne vois pas trop comment faire tout ça avec des références.
JM
--
Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Y a pas bug, là ? Que veux-tu dire par "pas de polymorphisme avec les références" ?
Je voulais parler de mon problème. On peut bien entendu (après vérification je n'étais pas sûr :p) écrire : fille f; mere & m = f;
Comme on peut écrire : mere * m = new fille;
Par contre je n'ai jamais eu besoin d'utiliser des références pour du polymorphisme, j'ai toujours recourt aux pointeurs. Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout ça avec des références.
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Zouplaz
Jean-Marc Molina - :
Pour ma part je m'en suis servi pour un moteur 3D (arbre compos de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout a avec des rfrences.
Haaa !! J'adhère au club ! Ex ancien projet identique (sauf l'IA puisque projet aborté après la phase 3D) et j'ai toujours fait mes new et delete tout seul (en connaissant les limitations et les dangers) et avec des références, moi non plus, je ne vois pas comment j'aurais pu faire...
Pour ma part je m'en suis servi pour un moteur 3D (arbre compos de
nodes), IA, animation (keyframing)... Tout se passe au runtime, en
dynamique alors je ne vois pas trop comment faire tout a avec des
rfrences.
Haaa !! J'adhère au club ! Ex ancien projet identique (sauf l'IA puisque
projet aborté après la phase 3D) et j'ai toujours fait mes new et delete
tout seul (en connaissant les limitations et les dangers) et avec des
références, moi non plus, je ne vois pas comment j'aurais pu faire...
Pour ma part je m'en suis servi pour un moteur 3D (arbre compos de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout a avec des rfrences.
Haaa !! J'adhère au club ! Ex ancien projet identique (sauf l'IA puisque projet aborté après la phase 3D) et j'ai toujours fait mes new et delete tout seul (en connaissant les limitations et les dangers) et avec des références, moi non plus, je ne vois pas comment j'aurais pu faire...
Loïc Joly
Jean-Marc Molina wrote:
Par contre je n'ai jamais eu besoin d'utiliser des références pour du polymorphisme, j'ai toujours recourt aux pointeurs. Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout ça avec des références.
Par contre je n'ai jamais eu besoin d'utiliser des références pour du
polymorphisme, j'ai toujours recourt aux pointeurs.
Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes),
IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors
je ne vois pas trop comment faire tout ça avec des références.
Par contre je n'ai jamais eu besoin d'utiliser des références pour du polymorphisme, j'ai toujours recourt aux pointeurs. Tu as un exemple d'utilisation ?
Pour ma part je m'en suis servi pour un moteur 3D (arbre composé de nodes), IA, animation (keyframing)... Tout se passe au runtime, en dynamique alors je ne vois pas trop comment faire tout ça avec des références.
