new[]/delete[] et VC6

Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Entraide Développement Développement Langage C++ new[]/delete[] et VC6

3 réponses

Gilles

25/08/2004 à 11:54

Bonjour,

J'ai un problème avec les opérateurs new[] et delete[] sous VC6.
J'écris une lib dans laquelle j'utilise des opérateurs non standards:

// malib.h
#include <new>
#include <malloc.h>
struct MyStruct {};
MyStruct myStruct;
void* operator new[](size_t s, MyStruct) {
return malloc(s);
}
void operator delete[](void* p, MyStruct) {
free(p);
}

J'aimerais que les utilisateurs de cette lib puissent utiliser mes
opérateurs ainsi que les opérateurs standards. Et c'est là que ça coince.
Lorsque j'inclus ce header dans un projet, j'obtient une erreur de
compilation avec VC6:

// monprojet.cpp
#include "malib.h"
int main()
{
int* a = new int[10];
delete[] a;
return 0;
}

-> 'new[]' : function does not take 1 parameters
-> 'delete[]' : function does not take 1 parameters
On dirait que VC6 ne connaît plus les opérateurs standards dès qu'on en
définit d'autres.

NB: VC6 est le seul des 9 compilateurs que j'utilise à générer une erreur.

En cresant un peu, je me suis aperçu que les operateurs new[]/delete[]
standards ne sont pas déclarés dans le header 'new' de VC6.
D'où l'idée de les déclarer dans mon header 'malib.h', comme ceci:
void* operator new[](size_t s) throw(std::bad_alloc);
void operator delete[](void* p) throw();

Mais je suis alors obligé de donner une définition de ces opérateurs dans
mon 'monprojet.cpp', sans quoi j'obtient une erreur de link (symboles non
définis):
void* operator new[](size_t s) throw(std::bad_alloc)
{
void* p = malloc(s);
if (!p)
throw(std::bad_alloc());
return p;
}
void operator delete[](void* p) throw()
{
free(p);
}
Je ne suis pas satisfait avec cette solution car j'oblige les utilisateurs
de ma lib à redéfinir les opérateurs standards.

Comme je ne suis pas à l'aise avec ces histoires d'opérateurs new/delete,
j'aurais voulu avoir quelques conseils d'experts.

Merci,
Gilles.

3 réponses

Gilles

30/08/2004 à 14:10

Bonjour,

Mon problème est-il mal posé ou bien n'intéresse-t-il vraiment personne ?
Le cas échéant, merci de m'indiquer un forum mieux approprié.

Gilles.

"Gilles" a écrit dans le message de
news:cghnl7$2bu6$
| Bonjour,
|
| J'ai un problème avec les opérateurs new[] et delete[] sous VC6.
| J'écris une lib dans laquelle j'utilise des opérateurs non standards:
|
| // malib.h
| #include <new>
| #include <malloc.h>
| struct MyStruct {};
| MyStruct myStruct;
| void* operator new[](size_t s, MyStruct) {
| return malloc(s);
| }
| void operator delete[](void* p, MyStruct) {
| free(p);
| }
|
| J'aimerais que les utilisateurs de cette lib puissent utiliser mes
| opérateurs ainsi que les opérateurs standards. Et c'est là que ça coince.
| Lorsque j'inclus ce header dans un projet, j'obtient une erreur de
| compilation avec VC6:
|
| // monprojet.cpp
| #include "malib.h"
| int main()
| {
| int* a = new int[10];
| delete[] a;
| return 0;
| }
|
| -> 'new[]' : function does not take 1 parameters
| -> 'delete[]' : function does not take 1 parameters
| On dirait que VC6 ne connaît plus les opérateurs standards dès qu'on en
| définit d'autres.
|
| NB: VC6 est le seul des 9 compilateurs que j'utilise à générer une erreur.
|
| En cresant un peu, je me suis aperçu que les operateurs new[]/delete[]
| standards ne sont pas déclarés dans le header 'new' de VC6.
| D'où l'idée de les déclarer dans mon header 'malib.h', comme ceci:
| void* operator new[](size_t s) throw(std::bad_alloc);
| void operator delete[](void* p) throw();
|
| Mais je suis alors obligé de donner une définition de ces opérateurs dans
| mon 'monprojet.cpp', sans quoi j'obtient une erreur de link (symboles non
| définis):
| void* operator new[](size_t s) throw(std::bad_alloc)
| {
| void* p = malloc(s);
| if (!p)
| throw(std::bad_alloc());
| return p;
| }
| void operator delete[](void* p) throw()
| {
| free(p);
| }
| Je ne suis pas satisfait avec cette solution car j'oblige les utilisateurs
| de ma lib à redéfinir les opérateurs standards.
|
| Comme je ne suis pas à l'aise avec ces histoires d'opérateurs new/delete,
| j'aurais voulu avoir quelques conseils d'experts.
|
| Merci,
| Gilles.
|
|

Bonjour,

Mon problème est-il mal posé ou bien n'intéresse-t-il vraiment personne ?
Le cas échéant, merci de m'indiquer un forum mieux approprié.

Gilles.

"Gilles" <nospam@nospam.com> a écrit dans le message de
news:cghnl7$2bu6$1@biggoron.nerim.net...
| Bonjour,
|
| J'ai un problème avec les opérateurs new[] et delete[] sous VC6.
| J'écris une lib dans laquelle j'utilise des opérateurs non standards:
|
| // malib.h
| #include <new>
| #include <malloc.h>
| struct MyStruct {};
| MyStruct myStruct;
| void* operator new[](size_t s, MyStruct) {
| return malloc(s);
| }
| void operator delete[](void* p, MyStruct) {
| free(p);
| }
|
| J'aimerais que les utilisateurs de cette lib puissent utiliser mes
| opérateurs ainsi que les opérateurs standards. Et c'est là que ça coince.
| Lorsque j'inclus ce header dans un projet, j'obtient une erreur de
| compilation avec VC6:
|
| // monprojet.cpp
| #include "malib.h"
| int main()
| {
| int* a = new int[10];
| delete[] a;
| return 0;
| }
|
| -> 'new[]' : function does not take 1 parameters
| -> 'delete[]' : function does not take 1 parameters
| On dirait que VC6 ne connaît plus les opérateurs standards dès qu'on en
| définit d'autres.
|
| NB: VC6 est le seul des 9 compilateurs que j'utilise à générer une erreur.
|
| En cresant un peu, je me suis aperçu que les operateurs new[]/delete[]
| standards ne sont pas déclarés dans le header 'new' de VC6.
| D'où l'idée de les déclarer dans mon header 'malib.h', comme ceci:
| void* operator new[](size_t s) throw(std::bad_alloc);
| void operator delete[](void* p) throw();
|
| Mais je suis alors obligé de donner une définition de ces opérateurs dans
| mon 'monprojet.cpp', sans quoi j'obtient une erreur de link (symboles non
| définis):
| void* operator new[](size_t s) throw(std::bad_alloc)
| {
| void* p = malloc(s);
| if (!p)
| throw(std::bad_alloc());
| return p;
| }
| void operator delete[](void* p) throw()
| {
| free(p);
| }
| Je ne suis pas satisfait avec cette solution car j'oblige les utilisateurs
| de ma lib à redéfinir les opérateurs standards.
|
| Comme je ne suis pas à l'aise avec ces histoires d'opérateurs new/delete,
| j'aurais voulu avoir quelques conseils d'experts.
|
| Merci,
| Gilles.
|
|

Vous avez filtré cet utilisateur ! Consultez son message

Bonjour,

Mon problème est-il mal posé ou bien n'intéresse-t-il vraiment personne ?
Le cas échéant, merci de m'indiquer un forum mieux approprié.

Gilles.

"Gilles" a écrit dans le message de
news:cghnl7$2bu6$
| Bonjour,
|
| J'ai un problème avec les opérateurs new[] et delete[] sous VC6.
| J'écris une lib dans laquelle j'utilise des opérateurs non standards:
|
| // malib.h
| #include <new>
| #include <malloc.h>
| struct MyStruct {};
| MyStruct myStruct;
| void* operator new[](size_t s, MyStruct) {
| return malloc(s);
| }
| void operator delete[](void* p, MyStruct) {
| free(p);
| }
|
| J'aimerais que les utilisateurs de cette lib puissent utiliser mes
| opérateurs ainsi que les opérateurs standards. Et c'est là que ça coince.
| Lorsque j'inclus ce header dans un projet, j'obtient une erreur de
| compilation avec VC6:
|
| // monprojet.cpp
| #include "malib.h"
| int main()
| {
| int* a = new int[10];
| delete[] a;
| return 0;
| }
|
| -> 'new[]' : function does not take 1 parameters
| -> 'delete[]' : function does not take 1 parameters
| On dirait que VC6 ne connaît plus les opérateurs standards dès qu'on en
| définit d'autres.
|
| NB: VC6 est le seul des 9 compilateurs que j'utilise à générer une erreur.
|
| En cresant un peu, je me suis aperçu que les operateurs new[]/delete[]
| standards ne sont pas déclarés dans le header 'new' de VC6.
| D'où l'idée de les déclarer dans mon header 'malib.h', comme ceci:
| void* operator new[](size_t s) throw(std::bad_alloc);
| void operator delete[](void* p) throw();
|
| Mais je suis alors obligé de donner une définition de ces opérateurs dans
| mon 'monprojet.cpp', sans quoi j'obtient une erreur de link (symboles non
| définis):
| void* operator new[](size_t s) throw(std::bad_alloc)
| {
| void* p = malloc(s);
| if (!p)
| throw(std::bad_alloc());
| return p;
| }
| void operator delete[](void* p) throw()
| {
| free(p);
| }
| Je ne suis pas satisfait avec cette solution car j'oblige les utilisateurs
| de ma lib à redéfinir les opérateurs standards.
|
| Comme je ne suis pas à l'aise avec ces histoires d'opérateurs new/delete,
| j'aurais voulu avoir quelques conseils d'experts.
|
| Merci,
| Gilles.
|
|

Loïc Joly

30/08/2004 à 18:44

Gilles wrote:

Bonjour,

Mon problème est-il mal posé ou bien n'intéresse-t-il vraiment personne ?

Ou alors simplement on n'a pas d'idées... As-tu le même résultat en
déclarant ces fonctions dans ta classe ?

--
Loïc

Gilles

30/08/2004 à 19:41

| Ou alors simplement on n'a pas d'idées... As-tu le même résultat en
| déclarant ces fonctions dans ta classe ?

De quelle classe parles tu ?
Je précise mon besoin: je veux définir un operator new[] (et le detele[]
associé) afin qu'on puisse aussi l'utiliser à l'extérieur de ma lib. Avec
cet opérator new[], je souhaite allouer de la mémoire pour des types de base
(int, char...) et pour des objets.

Gilles.

new[]/delete[] et VC6

3 réponses

Veuillez sélectionner un problème