J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc)
{...
}
void operator delete (void *ptr) throw()
{....
}
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete.
Cependant, à quoi servent les instructions throw se trouvant au niveau de la
définition de la fonction et non dans le corps de la fonction ?
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
Benoit Rousseau
Michel Champe wrote:
Bonjour,
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Michel Champe wrote:
Bonjour,
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc)
{...
}
void operator delete (void *ptr) throw()
{....
}
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete.
Cependant, à quoi servent les instructions throw se trouvant au niveau de la
définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type
std::bad_alloc si elle échoue
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Magnet
Benoit Rousseau racontait :
Michel Champe wrote:
Bonjour,
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire remonter une exception, on peut rajouter à sa signature (et tout à la fin, après le qualificatif const) : throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de changer le handler de new (set_new_handler), new renvoie systématiquement std::bad_alloc quand il ne peut effectuer une allocation (et donc, pas un pointeur nul).
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc)
{...
}
void operator delete (void *ptr) throw()
{....
}
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et
delete. Cependant, à quoi servent les instructions throw se trouvant
au niveau de la définition de la fonction et non dans le corps de la
fonction ?
A indiquer que la fonction peut lever une exception de type
std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des
types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire
remonter une exception, on peut rajouter à sa signature (et tout à la
fin, après le qualificatif const) :
throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à
fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de
changer le handler de new (set_new_handler), new renvoie
systématiquement std::bad_alloc quand il ne peut effectuer une
allocation (et donc, pas un pointeur nul).
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire remonter une exception, on peut rajouter à sa signature (et tout à la fin, après le qualificatif const) : throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de changer le handler de new (set_new_handler), new renvoie systématiquement std::bad_alloc quand il ne peut effectuer une allocation (et donc, pas un pointeur nul).
-- Magnet
Michel Champe
Merci pour ces infos....
"Magnet" a écrit dans le message de news: br0bdk$25li$
Benoit Rousseau racontait :
Michel Champe wrote:
Bonjour,
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire remonter une exception, on peut rajouter à sa signature (et tout à la fin, après le qualificatif const) : throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de changer le handler de new (set_new_handler), new renvoie systématiquement std::bad_alloc quand il ne peut effectuer une allocation (et donc, pas un pointeur nul).
-- Magnet
Merci pour ces infos....
"Magnet" <magnet@nospam.com> a écrit dans le message de news:
br0bdk$25li$1@biggoron.nerim.net...
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc)
{...
}
void operator delete (void *ptr) throw()
{....
}
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et
delete. Cependant, à quoi servent les instructions throw se trouvant
au niveau de la définition de la fonction et non dans le corps de la
fonction ?
A indiquer que la fonction peut lever une exception de type
std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des
types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire
remonter une exception, on peut rajouter à sa signature (et tout à la
fin, après le qualificatif const) :
throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à
fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de
changer le handler de new (set_new_handler), new renvoie
systématiquement std::bad_alloc quand il ne peut effectuer une
allocation (et donc, pas un pointeur nul).
"Magnet" a écrit dans le message de news: br0bdk$25li$
Benoit Rousseau racontait :
Michel Champe wrote:
Bonjour,
J'ai vu les instructions suivantes dans un programme C++ :
void *operator new (RTRT_SIZE_T size) throw (std::bad_alloc) {... }
void operator delete (void *ptr) throw() {.... }
Je comprends qu'il s'agit d'une redéfinition des opérateurs new et delete. Cependant, à quoi servent les instructions throw se trouvant au niveau de la définition de la fonction et non dans le corps de la fonction ?
A indiquer que la fonction peut lever une exception de type std::bad_alloc si elle échoue
Par ailleurs, elles ne pourront faire remonter QUE des exceptions des types indiqués.
Par exemple, si on veut empecher une fonction quelconque de faire remonter une exception, on peut rajouter à sa signature (et tout à la fin, après le qualificatif const) : throw (void)
C'est ce que fait delete dans l'exemple ci-dessus, ce qui est tout à fait normal car delete ne doit _jamais_ renvoyer d'exception. A moins de changer le handler de new (set_new_handler), new renvoie systématiquement std::bad_alloc quand il ne peut effectuer une allocation (et donc, pas un pointeur nul).
