toujours pour piger un peu mieux le C++, j'ai une question sur le sujet
de la surcharge des constructeurs, et de l'appel a d'autres
constructeurs...
bref concrètement j'ai fait :
class ma_classe
{
public:
vector<unsigned int> tab; //tableau de taille nulle pour le
moment...
ma_classe(); // constructeur par défaut, ici, ne
fait rien
ma_classe(unsigned int taille); //constructeur surchargé, prend
une taille en arg
void affiche(); // affiche le tableau membre
};
/*
j'aimerai que le constructeur surchargé me fasse un vector de taille
donnée comme paramètre
*/
ma_classe::ma_classe() //ne fait rien
{
}
ma_classe::ma_classe(unsigned int taille)
:tab(taille) // correct d'utiliser le paramètre du constructeur comme
ça ?
{
for(unsigned int i=0;i<tab.size();i++)
tab[i]=i; //initialise toutes les cases du vector
}
void ma_classe::affiche()
{
if(this->tab.size()!=0)
{
for(unsigned int i=0;i<tab.size();i++)
cout<<tab[i]<<" ";
cout<<endl;
}
else
cout<<"tableau de taille nulle, rien a afficher !"<<endl;
}
donc ça a l'air de marcher, je me demande juste si ce que je fais est
bien valide vis à vis du C++ (car j'ai vu pas mal de trucs non standard
permis par les compilos et je me méfie)
question bonus, comment faire pour la déclaration d'un objet de façon
dynamique pour utiliser le constructeur surchargé ?
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
Vincent Lascaux
donc ça a l'air de marcher, je me demande juste si ce que je fais est bien valide vis à vis du C++ (car j'ai vu pas mal de trucs non standard permis par les compilos et je me méfie)
Oui, c'est tout bon (il me semble du moins)
question bonus, comment faire pour la déclaration d'un objet de façon dynamique pour utiliser le constructeur surchargé ?
Je suis pas sur de comprendre la question... Est ce que le code suivant t'eclaire ?
donc ça a l'air de marcher, je me demande juste si ce que je fais est
bien valide vis à vis du C++ (car j'ai vu pas mal de trucs non standard
permis par les compilos et je me méfie)
Oui, c'est tout bon (il me semble du moins)
question bonus, comment faire pour la déclaration d'un objet de façon
dynamique pour utiliser le constructeur surchargé ?
Je suis pas sur de comprendre la question... Est ce que le code suivant
t'eclaire ?
donc ça a l'air de marcher, je me demande juste si ce que je fais est bien valide vis à vis du C++ (car j'ai vu pas mal de trucs non standard permis par les compilos et je me méfie)
Oui, c'est tout bon (il me semble du moins)
question bonus, comment faire pour la déclaration d'un objet de façon dynamique pour utiliser le constructeur surchargé ?
Je suis pas sur de comprendre la question... Est ce que le code suivant t'eclaire ?
le constructeur de CFoo prend un entier i comme argument, et appel le constructeur de data qui .... prend l'adresse d'un int renvoyé par new... ça me semble assez compliqué comme syntaxe...
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
le constructeur de CFoo prend un entier i comme argument, et appel le
constructeur de data qui .... prend l'adresse d'un int renvoyé par
new... ça me semble assez compliqué comme syntaxe...
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un
objet dynamique C_Tab ?
le constructeur de CFoo prend un entier i comme argument, et appel le constructeur de data qui .... prend l'adresse d'un int renvoyé par new... ça me semble assez compliqué comme syntaxe...
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
question bonus, comment faire pour la déclaration d'un objet de façon dynamique pour utiliser le constructeur surchargé ?
Je suis pas sur de comprendre la question...
Je ne suis pas sur non plus, mais j'ai compris différemment :
int main() { ma_classe *a = new ma_classe(10); ma_classe *b (new maclasse(20)); ma_classe *c = new ma_classe;; a->affiche(); b->affiche(); c->affiche(); delete a; delete b; delete c; return 0; }
-- Loïc
.oO LGV Oo.
"Vincent Lascaux" a écrit dans le message de news:3fc508cf$0$18452$
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments); ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2 au début
-- Vincent
juste pour aller un poil plus loin, pour initialiser une collection d'objets avec autre chose que le constructeur par défaut, on combinera un operator new avec un placement new, genre :
C_Tab array[10]; // crée un tableau de 10 objets initialisés avec les ctor par _défaut_
Vs.
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour 10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:3fc508cf$0$18452$626a54ce@news.free.fr...
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un
objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments);
ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2
au début
--
Vincent
juste pour aller un poil plus loin, pour initialiser une collection d'objets
avec autre chose que le constructeur par défaut, on combinera un operator
new avec un placement new, genre :
C_Tab array[10]; // crée un tableau de 10 objets initialisés avec les ctor
par _défaut_
Vs.
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour
10 instances
for (int index = 0; index < 10; index++)
new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque
objet avec le ctor avec 1 param
C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
"Vincent Lascaux" a écrit dans le message de news:3fc508cf$0$18452$
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments); ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2 au début
-- Vincent
juste pour aller un poil plus loin, pour initialiser une collection d'objets avec autre chose que le constructeur par défaut, on combinera un operator new avec un placement new, genre :
C_Tab array[10]; // crée un tableau de 10 objets initialisés avec les ctor par _défaut_
Vs.
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour 10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
Vincent Lascaux
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour
10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
Comme on dit, y a pas photo
-- Vincent
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem
pour
10 instances
for (int index = 0; index < 10; index++)
new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque
objet avec le ctor avec 1 param
C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de
pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj;
obj.reserve(10);
for(int index = 0; index < 10; index++)
obj.push_back(C_Tab(2));
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour
10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
Comme on dit, y a pas photo
-- Vincent
.oO LGV Oo.
"Vincent Lascaux" a écrit dans le message de news:3fc508cf$0$18452$
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments); ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2 au début
-- Vincent
pour plus de rigueur quant à l'initialisation d'une collection sur un ctor avec paramètre, un petit bout des astuces de tonton Meyers:
// allocate enough raw memory for an array of 10 // EquipmentPiece objects; see Item 8 for details on // the operator new[] function void *rawMemory operator new[](10*sizeof(EquipmentPiece)); // make bestPieces point to it so it can be treated as an // EquipmentPiece array EquipmentPiece *bestPieces static_cast<EquipmentPiece*>(rawMemory); // construct the EquipmentPiece objects in the memory // using "placement new" (see Item 8) for (int i = 0; i < 10; ++i) new (&bestPieces[i]) EquipmentPiece( ID Number );
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:3fc508cf$0$18452$626a54ce@news.free.fr...
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un
objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments);
ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2
au début
--
Vincent
pour plus de rigueur quant à l'initialisation d'une collection sur un ctor
avec paramètre, un petit bout des astuces de tonton Meyers:
// allocate enough raw memory for an array of 10
// EquipmentPiece objects; see Item 8 for details on
// the operator new[] function
void *rawMemory operator new[](10*sizeof(EquipmentPiece));
// make bestPieces point to it so it can be treated as an
// EquipmentPiece array
EquipmentPiece *bestPieces static_cast<EquipmentPiece*>(rawMemory);
// construct the EquipmentPiece objects in the memory
// using "placement new" (see Item 8)
for (int i = 0; i < 10; ++i)
new (&bestPieces[i]) EquipmentPiece( ID Number );
"Vincent Lascaux" a écrit dans le message de news:3fc508cf$0$18452$
ce que je voulais dire, sans etre clair peut-etre, c'est comme créer un objet dynamique C_Tab ?
C_Tab *obj=new ???
C_Tab *obj = new C_Tab(arguments); ma_classe* a = new ma_classe(2); // cree une instance avec une taille de 2 au début
-- Vincent
pour plus de rigueur quant à l'initialisation d'une collection sur un ctor avec paramètre, un petit bout des astuces de tonton Meyers:
// allocate enough raw memory for an array of 10 // EquipmentPiece objects; see Item 8 for details on // the operator new[] function void *rawMemory operator new[](10*sizeof(EquipmentPiece)); // make bestPieces point to it so it can be treated as an // EquipmentPiece array EquipmentPiece *bestPieces static_cast<EquipmentPiece*>(rawMemory); // construct the EquipmentPiece objects in the memory // using "placement new" (see Item 8) for (int i = 0; i < 10; ++i) new (&bestPieces[i]) EquipmentPiece( ID Number );
.oO LGV Oo.
"Vincent Lascaux" a écrit dans le message de news:3fc5202b$0$18460$
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour
10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
Comme on dit, y a pas photo
-- Vincent
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit, combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut et ne connaissent pas l'existence du placement new ? ...
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:3fc5202b$0$18460$626a54ce@news.free.fr...
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem
pour
10 instances
for (int index = 0; index < 10; index++)
new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque
objet avec le ctor avec 1 param
C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de
pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj;
obj.reserve(10);
for(int index = 0; index < 10; index++)
obj.push_back(C_Tab(2));
Comme on dit, y a pas photo
--
Vincent
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut
et ne connaissent pas l'existence du placement new ? ...
"Vincent Lascaux" a écrit dans le message de news:3fc5202b$0$18460$
void *p_raw_mem = operator new(10*sizeof(C_Tab)); // reserve de la mem pour
10 instances for (int index = 0; index < 10; index++) new (p_raw_mem + index*sizeof(C_Tab)) C_Tab(2); // initialise chaque objet avec le ctor avec 1 param C_Tab *p_obj = reinterpret_cast<C_Tab *>(p_raw_mem); // histoire de pouvoir
manipuler facilement par la suite
à vérifier/confirmer, mais si je me rappelle bien, c'est l'idée...
à comparer avec
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
Comme on dit, y a pas photo
-- Vincent
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit, combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut et ne connaissent pas l'existence du placement new ? ...
Vincent Lascaux
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ? Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du placement new preferable à std::vector.
-- Vincent
std::vector<C_Tab> obj;
obj.reserve(10);
for(int index = 0; index < 10; index++)
obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela
dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par
défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ?
Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du
placement new preferable à std::vector.
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ? Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du placement new preferable à std::vector.
-- Vincent
.oO LGV Oo.
"Vincent Lascaux" a écrit dans le message de news:3fc618ce$0$18423$
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ? Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du placement new preferable à std::vector.
-- Vincent
je ne plébiscite pas l'une ou l'autre des méthodes, je suis simplement partisan du fait que plus on connait de choses, plus on a de possibilités parmi lesquelles choisir pour répondre à un problème, rien de plus... donc il me semble bon de connaitre à la fois les std::vector et les placement new ; de toute manière je ne souhaite aucunement rentrer dans une polémique qui, à n'en pas douter, ne passionnera personne.
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:3fc618ce$0$18423$626a54ce@news.free.fr...
std::vector<C_Tab> obj;
obj.reserve(10);
for(int index = 0; index < 10; index++)
obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela
dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par
défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ?
Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du
placement new preferable à std::vector.
--
Vincent
je ne plébiscite pas l'une ou l'autre des méthodes, je suis simplement
partisan du fait que plus on connait de choses, plus on a de possibilités
parmi lesquelles choisir pour répondre à un problème, rien de plus... donc
il me semble bon de connaitre à la fois les std::vector et les placement new
; de toute manière je ne souhaite aucunement rentrer dans une polémique qui,
à n'en pas douter, ne passionnera personne.
"Vincent Lascaux" a écrit dans le message de news:3fc618ce$0$18423$
std::vector<C_Tab> obj; obj.reserve(10); for(int index = 0; index < 10; index++) obj.push_back(C_Tab(2));
dans ce cas trivial je ne peux qu'être évidemment d'accord ; mais cela dit,
combien tentent de créer des tableaux d'objets dépourvus de ctor par défaut
et ne connaissent pas l'existence du placement new ? ...
Et à ces gens, tu conseilles d'apprendre le placement new ou std::vector ? Et je ne vois pas en quoi un cas plus compliqué va rendre l'utilisation du placement new preferable à std::vector.
-- Vincent
je ne plébiscite pas l'une ou l'autre des méthodes, je suis simplement partisan du fait que plus on connait de choses, plus on a de possibilités parmi lesquelles choisir pour répondre à un problème, rien de plus... donc il me semble bon de connaitre à la fois les std::vector et les placement new ; de toute manière je ne souhaite aucunement rentrer dans une polémique qui, à n'en pas douter, ne passionnera personne.
