Je programme en VC6++, mais j'ai encore certaines "lacunes" en
programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type
pile ou file, qui me permettrait une gestion un peu plus dynamique de la
memoire, notamment au stade ou j'en suis je cree des tableaux de 100
"cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
C'est un exercice typique et ca doit se trouver facilement sur le Web.
Pour une implementation robuste, utilise la STL.
-- « Willy, j'ai mangé le chat. »
Bonjour,
MALIS Pierre-Yves a écrit :
Je programme en VC6++, mais j'ai encore certaines "lacunes" en
programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type
pile ou file, qui me permettrait une gestion un peu plus dynamique de la
memoire, notamment au stade ou j'en suis je cree des tableaux de 100
"cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
C'est un exercice typique et ca doit se trouver facilement sur le Web.
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
C'est un exercice typique et ca doit se trouver facilement sur le Web.
Pour une implementation robuste, utilise la STL.
-- « Willy, j'ai mangé le chat. »
Ambassadeur Kosh
> J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool. Pierre-Yves.
ok, c'est parti
soit tu utilises la stl, un ensemble de templates, donc de classes pour les containers et les algos toutes pretes. genre ça :
#include <stack> using namespaces std ;
void f() { statck<double> pile1 ;
pile1.push(25.6) ; pile1.push(27.8) ;
pile1.pop() ;
const double x = pile1.top() ; }
soit tu fais la tienne en utilisant la représentation qui te convient le mieux. j'imagine que c'est ce que tu souhaite. le mieux, c'est quand même de faire un template. dans les représentations, il y'a deux façons de faire. le bloc de mémoire qu'on réalloue, et le chainage.
la mémoire qu'on réalloue passe par l'api C malloc, realloc et free. tu peux substituer new à malloc et delete à free pour les objets (on va dire comme ça), mais il faudra faire des choses tres "spéciales" pour le realloc (constructeurs de copie des nouveaux objets, tout ça), mais bon, commençons par du simple.
Noeud *premier = new Noeud(NULL,25.89) ; Noeud *dernier = premier ;
premier = new Noeud(premier,89.65) ; premier = new Noeud(premier,123.47) ;
// parcours de la liste for(Noeud *i=premier;i!=NULL;i=i->suivant) { double v = i->value ; ... }
// suppression du premier élément Noeud *vieux = premier ; premier = premier->suivant ; delete vieux ;
les structures plus compliquées utilisent le mélange de ces deux techniques. le but étant d'obtenir des bonnes perfs pour les propriétés qu'on veut garantir. apres, il faut connaitre les effets, le cout, et les vertus de malloc, realloc, free, new et delete.
pour un arbre binaire, on peut utiliser un Noeud avec un champ fils gauche, fils droit. pour une liste, on peut utiliser un Noeud dont la value est un bloc de mémoire, et qui a un suivant et un precedent... bref...
l'exemple du Noeud devrait coller directement avec ta pile. reste à en faire une classe, avec les opérations qui vont bien.
j'espere que ça va aider un peu.
sinon, on avancera point par point...
voila voila
> J'aimerais notamment avoir des exemples de structures de donnees de type
pile ou file, qui me permettrait une gestion un peu plus dynamique de la
memoire, notamment au stade ou j'en suis je cree des tableaux de 100
"cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
Pierre-Yves.
ok, c'est parti
soit tu utilises la stl, un ensemble de templates, donc de classes pour les
containers et les algos toutes pretes.
genre ça :
#include <stack>
using namespaces std ;
void f()
{
statck<double> pile1 ;
pile1.push(25.6) ;
pile1.push(27.8) ;
pile1.pop() ;
const double x = pile1.top() ;
}
soit tu fais la tienne en utilisant la représentation qui te convient le
mieux.
j'imagine que c'est ce que tu souhaite. le mieux, c'est quand même de faire
un template.
dans les représentations, il y'a deux façons de faire. le bloc de mémoire
qu'on réalloue, et le chainage.
la mémoire qu'on réalloue passe par l'api C malloc, realloc et free. tu peux
substituer new à malloc et delete à free pour les objets (on va dire comme
ça), mais il faudra faire des choses tres "spéciales" pour le realloc
(constructeurs de copie des nouveaux objets, tout ça), mais bon, commençons
par du simple.
Noeud *premier = new Noeud(NULL,25.89) ;
Noeud *dernier = premier ;
premier = new Noeud(premier,89.65) ;
premier = new Noeud(premier,123.47) ;
// parcours de la liste
for(Noeud *i=premier;i!=NULL;i=i->suivant)
{
double v = i->value ;
...
}
// suppression du premier élément
Noeud *vieux = premier ;
premier = premier->suivant ;
delete vieux ;
les structures plus compliquées utilisent le mélange de ces deux techniques.
le but étant d'obtenir des bonnes perfs pour les propriétés qu'on veut
garantir.
apres, il faut connaitre les effets, le cout, et les vertus de malloc,
realloc, free, new et delete.
pour un arbre binaire, on peut utiliser un Noeud avec un champ fils gauche,
fils droit. pour une liste, on peut utiliser un Noeud dont la value est un
bloc de mémoire, et qui a un suivant et un precedent... bref...
l'exemple du Noeud devrait coller directement avec ta pile. reste à en faire
une classe, avec les opérations qui vont bien.
> J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool. Pierre-Yves.
ok, c'est parti
soit tu utilises la stl, un ensemble de templates, donc de classes pour les containers et les algos toutes pretes. genre ça :
#include <stack> using namespaces std ;
void f() { statck<double> pile1 ;
pile1.push(25.6) ; pile1.push(27.8) ;
pile1.pop() ;
const double x = pile1.top() ; }
soit tu fais la tienne en utilisant la représentation qui te convient le mieux. j'imagine que c'est ce que tu souhaite. le mieux, c'est quand même de faire un template. dans les représentations, il y'a deux façons de faire. le bloc de mémoire qu'on réalloue, et le chainage.
la mémoire qu'on réalloue passe par l'api C malloc, realloc et free. tu peux substituer new à malloc et delete à free pour les objets (on va dire comme ça), mais il faudra faire des choses tres "spéciales" pour le realloc (constructeurs de copie des nouveaux objets, tout ça), mais bon, commençons par du simple.
Noeud *premier = new Noeud(NULL,25.89) ; Noeud *dernier = premier ;
premier = new Noeud(premier,89.65) ; premier = new Noeud(premier,123.47) ;
// parcours de la liste for(Noeud *i=premier;i!=NULL;i=i->suivant) { double v = i->value ; ... }
// suppression du premier élément Noeud *vieux = premier ; premier = premier->suivant ; delete vieux ;
les structures plus compliquées utilisent le mélange de ces deux techniques. le but étant d'obtenir des bonnes perfs pour les propriétés qu'on veut garantir. apres, il faut connaitre les effets, le cout, et les vertus de malloc, realloc, free, new et delete.
pour un arbre binaire, on peut utiliser un Noeud avec un champ fils gauche, fils droit. pour une liste, on peut utiliser un Noeud dont la value est un bloc de mémoire, et qui a un suivant et un precedent... bref...
l'exemple du Noeud devrait coller directement avec ta pile. reste à en faire une classe, avec les opérations qui vont bien.
j'espere que ça va aider un peu.
sinon, on avancera point par point...
voila voila
adebaene
MALIS Pierre-Yves wrote in message news:...
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file,
Ca ne serait pas un exercice pour l'école des fois?
qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
std::vector et tous les autres containers de la STL (std::stack, std::queue, ...)
Arnaud
MALIS Pierre-Yves <linfg176@cict.fr> wrote in message news:<4003AEFE.C42E48F3@cict.fr>...
Je programme en VC6++, mais j'ai encore certaines "lacunes" en
programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type
pile ou file,
Ca ne serait pas un exercice pour l'école des fois?
qui me permettrait une gestion un peu plus dynamique de la
memoire, notamment au stade ou j'en suis je cree des tableaux de 100
"cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
std::vector et tous les autres containers de la STL (std::stack, std::queue, ...)
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file,
Ca ne serait pas un exercice pour l'école des fois?
qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
std::vector et tous les autres containers de la STL (std::stack, std::queue, ...)
Arnaud
Alexandre
"MALIS Pierre-Yves" a écrit dans le message de news:
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
Pierre-Yves.
pour une liste chainée : #include <list>
void main() { std::list<std::string> ListeDeChaines; ListeDeChaines.push_back("marcel"); ListeDeChaines.push_back("vincent"); // affiche le contenu de la liste for( std::list<std::string>::iterator i = ListeDeChaines.begin(); i ! ListeDeChaines.end(); ++i ) std::cout<< *i; }
la classe standard deque est (presque) identique mais autorise un accès indéxé (comme un tableau). la classe vector est un tableau, mais dynamique-qui-gère-tout-seul-la-mémoire-comme-un-grand.
Pour une pile, std::stack<int> PileEntiers; PileEntiers.push(3); PileEntiers.pop();
pour une file d'attende (FIFO) : std::queue<float> PileFlottants; PileFlottants.push(-8); PileFlottants.pop(); etc...
regardes la doc à STL.
"MALIS Pierre-Yves" <linfg176@cict.fr> a écrit dans le message de
news:4003AEFE.C42E48F3@cict.fr...
Je programme en VC6++, mais j'ai encore certaines "lacunes" en
programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type
pile ou file, qui me permettrait une gestion un peu plus dynamique de la
memoire, notamment au stade ou j'en suis je cree des tableaux de 100
"cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
Pierre-Yves.
pour une liste chainée :
#include <list>
void main()
{
std::list<std::string> ListeDeChaines;
ListeDeChaines.push_back("marcel");
ListeDeChaines.push_back("vincent");
// affiche le contenu de la liste
for( std::list<std::string>::iterator i = ListeDeChaines.begin(); i ! ListeDeChaines.end(); ++i )
std::cout<< *i;
}
la classe standard deque est (presque) identique mais autorise un accès
indéxé (comme un tableau).
la classe vector est un tableau, mais
dynamique-qui-gère-tout-seul-la-mémoire-comme-un-grand.
Pour une pile,
std::stack<int> PileEntiers;
PileEntiers.push(3);
PileEntiers.pop();
pour une file d'attende (FIFO) :
std::queue<float> PileFlottants;
PileFlottants.push(-8);
PileFlottants.pop();
etc...
"MALIS Pierre-Yves" a écrit dans le message de news:
Je programme en VC6++, mais j'ai encore certaines "lacunes" en programmation.
J'aimerais notamment avoir des exemples de structures de donnees de type pile ou file, qui me permettrait une gestion un peu plus dynamique de la memoire, notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci.
Si vous aviez un site simple ou je pourrais trouver ca ce serait cool.
Pierre-Yves.
pour une liste chainée : #include <list>
void main() { std::list<std::string> ListeDeChaines; ListeDeChaines.push_back("marcel"); ListeDeChaines.push_back("vincent"); // affiche le contenu de la liste for( std::list<std::string>::iterator i = ListeDeChaines.begin(); i ! ListeDeChaines.end(); ++i ) std::cout<< *i; }
la classe standard deque est (presque) identique mais autorise un accès indéxé (comme un tableau). la classe vector est un tableau, mais dynamique-qui-gère-tout-seul-la-mémoire-comme-un-grand.
Pour une pile, std::stack<int> PileEntiers; PileEntiers.push(3); PileEntiers.pop();
pour une file d'attende (FIFO) : std::queue<float> PileFlottants; PileFlottants.push(-8); PileFlottants.pop(); etc...
regardes la doc à STL.
Arnaud Debaene
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
tu peux substituer new à malloc et delete à free pour les objets (on va dire comme ça), mais il faudra faire des choses tres "spéciales" pour le realloc (constructeurs de copie des nouveaux objets, tout ça), mais bon, commençons par du simple.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts (constructeur par copie, operator=, etc...)
double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un bloc de 3 double
Ben où il est ton template?
Arnaud
Ambassadeur Kosh wrote:
<snip> le mieux, c'est quand même de faire un template.
<snip> malloc, realloc et free.
Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a
pas de sens de faire une classe template et de faire tes allocations avec
malloc! Ton template ne sera utilisable "correctement" que avec les types
primitifs et les PODs!
tu peux substituer new à malloc et delete à free pour les objets (on
va dire comme ça), mais il faudra faire des choses tres "spéciales"
pour le realloc (constructeurs de copie des nouveaux objets, tout
ça), mais bon, commençons par du simple.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts
(constructeur par copie, operator=, etc...)
double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un
bloc de 3 double
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
tu peux substituer new à malloc et delete à free pour les objets (on va dire comme ça), mais il faudra faire des choses tres "spéciales" pour le realloc (constructeurs de copie des nouveaux objets, tout ça), mais bon, commençons par du simple.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts (constructeur par copie, operator=, etc...)
double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un bloc de 3 double
Ben où il est ton template?
Arnaud
Luc Hermitte
"Arnaud Debaene" wrote in news:40043ffe$0$24049$:
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens. Pas si après ton allocation tu appelles l'opérateur de placement. Dans la STL, tu as une séparation entre les constructeurs qui sont exécutés sur les données de begin() à end(), mais plus au delà. La capacité est plus grande que a taille effective des collections. C'est n'est pas new[] qui est utilisé. Regarde le code de reserve() par exemple.
Si en interne on utilisait new[], on ne pourrait pas avoir de vecteur sur des classes qui n'ont pas de constructeur sans arguments (/avec constructeur sans arguments privé).
-- Luc Hermitte
"Arnaud Debaene" <adebaene@club-internet.fr> wrote in
news:40043ffe$0$24049$626a54ce@news.free.fr:
Ambassadeur Kosh wrote:
<snip> le mieux, c'est quand même de faire un template.
<snip> malloc, realloc et free.
Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca
n'a pas de sens de faire une classe template et de faire tes
allocations avec malloc! Ton template ne sera utilisable
"correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens. Pas si après ton
allocation tu appelles l'opérateur de placement.
Dans la STL, tu as une séparation entre les constructeurs qui sont exécutés
sur les données de begin() à end(), mais plus au delà.
La capacité est plus grande que a taille effective des collections. C'est
n'est pas new[] qui est utilisé.
Regarde le code de reserve() par exemple.
Si en interne on utilisait new[], on ne pourrait pas avoir de vecteur sur
des classes qui n'ont pas de constructeur sans arguments (/avec
constructeur sans arguments privé).
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens. Pas si après ton allocation tu appelles l'opérateur de placement. Dans la STL, tu as une séparation entre les constructeurs qui sont exécutés sur les données de begin() à end(), mais plus au delà. La capacité est plus grande que a taille effective des collections. C'est n'est pas new[] qui est utilisé. Regarde le code de reserve() par exemple.
Si en interne on utilisait new[], on ne pourrait pas avoir de vecteur sur des classes qui n'ont pas de constructeur sans arguments (/avec constructeur sans arguments privé).
-- Luc Hermitte
Ambassadeur Kosh
> Je veux bien que tu simplifies, mais là tu racontes des trucs faux! pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
enfin Arnaud, std::vector utilise un tableau dynamique. à un moment ou a un autre, on arrive sur realloc. et std::vector c'est un template. mettre new pour malloc ou delete pour free, c'est un detail pedagogique. il est débutant, j'ai pas voulu le noyer. mais il faudra bien à un moment ou a un autre arriver sur l'allocation mémoire et l'appel des constructeurs / destructeurs.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts (constructeur par copie, operator=, etc...) > double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un > bloc de 3 double Ben où il est ton template?
ben pas la effectivement. j'ai dit que c'était l'ideal. j'ai pas dit que j'allais lui faire :)
j'ai estimé son niveau en partant de ce qu'il disait : 'notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci'. comme c'est un débutant, on commence par faire du simple. donc le template, pour ma part, ca sera pour plus tard.
mais maintenant que tu as amené le sujet, apres tout, pourquoi ne pas lui presenter ces éléments. la c'est toi qui voit.
A+ Arnaud
> Je veux bien que tu simplifies, mais là tu racontes des trucs faux!
pas de sens de faire une classe template et de faire tes allocations avec
malloc! Ton template ne sera utilisable "correctement" que avec les types
primitifs et les PODs!
enfin Arnaud, std::vector utilise un tableau dynamique. à un moment ou a un
autre, on arrive sur realloc. et std::vector c'est un template.
mettre new pour malloc ou delete pour free, c'est un detail pedagogique. il
est débutant, j'ai pas voulu le noyer. mais il faudra
bien à un moment ou a un autre arriver sur l'allocation mémoire et l'appel
des constructeurs / destructeurs.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts
(constructeur par copie, operator=, etc...)
> double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un
> bloc de 3 double
Ben où il est ton template?
ben pas la effectivement. j'ai dit que c'était l'ideal. j'ai pas dit que
j'allais lui faire :)
j'ai estimé son niveau en partant de ce qu'il disait :
'notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors
qu'en general je n'en utilise qu'une dizaine de celles-ci'.
comme c'est un débutant, on commence par faire du simple. donc le template,
pour ma part, ca sera pour plus tard.
mais maintenant que tu as amené le sujet, apres tout, pourquoi ne pas lui
presenter ces éléments. la c'est toi qui voit.
> Je veux bien que tu simplifies, mais là tu racontes des trucs faux! pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
enfin Arnaud, std::vector utilise un tableau dynamique. à un moment ou a un autre, on arrive sur realloc. et std::vector c'est un template. mettre new pour malloc ou delete pour free, c'est un detail pedagogique. il est débutant, j'ai pas voulu le noyer. mais il faudra bien à un moment ou a un autre arriver sur l'allocation mémoire et l'appel des constructeurs / destructeurs.
Ben oui, mais pour faire du template, il FAUT maitriser ces concepts (constructeur par copie, operator=, etc...) > double *bloc = (double *)malloc(sizeof(double)*3) ; // je cree un > bloc de 3 double Ben où il est ton template?
ben pas la effectivement. j'ai dit que c'était l'ideal. j'ai pas dit que j'allais lui faire :)
j'ai estimé son niveau en partant de ce qu'il disait : 'notamment au stade ou j'en suis je cree des tableaux de 100 "cases" alors qu'en general je n'en utilise qu'une dizaine de celles-ci'. comme c'est un débutant, on commence par faire du simple. donc le template, pour ma part, ca sera pour plus tard.
mais maintenant que tu as amené le sujet, apres tout, pourquoi ne pas lui presenter ces éléments. la c'est toi qui voit.
A+ Arnaud
Arnaud Debaene
Luc Hermitte wrote:
"Arnaud Debaene" wrote in news:40043ffe$0$24049$:
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens.
<snip> Arf, comme quoi on trouve toujours plus tatillon que soi! Tu as parfaitement raison bien entendu, ceci dit, présenter les constructeurs avec placement à un débutant ne me parait pas un modèle de pédagogie :-)
Arnaud
Luc Hermitte wrote:
"Arnaud Debaene" <adebaene@club-internet.fr> wrote in
news:40043ffe$0$24049$626a54ce@news.free.fr:
Ambassadeur Kosh wrote:
<snip> le mieux, c'est quand même de faire un template.
<snip> malloc, realloc et free.
Je veux bien que tu simplifies, mais là tu racontes des trucs faux!
Ca n'a pas de sens de faire une classe template et de faire tes
allocations avec malloc! Ton template ne sera utilisable
"correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens.
<snip>
Arf, comme quoi on trouve toujours plus tatillon que soi! Tu as parfaitement
raison bien entendu, ceci dit, présenter les constructeurs avec placement à
un débutant ne me parait pas un modèle de pédagogie :-)
Ambassadeur Kosh wrote: <snip> le mieux, c'est quand même de faire un template. <snip> malloc, realloc et free. Je veux bien que tu simplifies, mais là tu racontes des trucs faux! Ca n'a pas de sens de faire une classe template et de faire tes allocations avec malloc! Ton template ne sera utilisable "correctement" que avec les types primitifs et les PODs!
Nope. Bien au contraire, cela a énormément de sens.
<snip> Arf, comme quoi on trouve toujours plus tatillon que soi! Tu as parfaitement raison bien entendu, ceci dit, présenter les constructeurs avec placement à un débutant ne me parait pas un modèle de pédagogie :-)
Arnaud
Arnaud Debaene
Ambassadeur Kosh wrote:
mettre new pour malloc ou delete pour free, c'est un detail pedagogique.
Là je ne suis pas d'accord : La notion de constructeur, c'est l'une des premières choses qu'un débutant C++ devrait voir dès qu'il maîtrise les structures de controle élémentaires et les fonctions.
Arnaud
Ambassadeur Kosh wrote:
mettre new pour malloc ou delete pour free, c'est un detail
pedagogique.
Là je ne suis pas d'accord : La notion de constructeur, c'est l'une des
premières choses qu'un débutant C++ devrait voir dès qu'il maîtrise les
structures de controle élémentaires et les fonctions.
mettre new pour malloc ou delete pour free, c'est un detail pedagogique.
Là je ne suis pas d'accord : La notion de constructeur, c'est l'une des premières choses qu'un débutant C++ devrait voir dès qu'il maîtrise les structures de controle élémentaires et les fonctions.
Arnaud
MALIS Pierre-Yves
Merci a tous.
Meme si le sujet est parti un peu dans tous les sens, je pense que je vais essayer de jeter un petit coup d'oeil, et non ce n'est pas pour "l'ecole", a mon stade on appelle ca la fac, mais je n'ai fais les piles qu'en ADA et c'etait beaucoup plus simple ( dans mes souvenirs en tout cas...)
Py
Merci a tous.
Meme si le sujet est parti un peu dans tous les sens, je pense que je vais
essayer de jeter un petit coup d'oeil, et non ce n'est pas pour "l'ecole", a
mon stade on appelle ca la fac, mais je n'ai fais les piles qu'en ADA et
c'etait beaucoup plus simple ( dans mes souvenirs en tout cas...)
Meme si le sujet est parti un peu dans tous les sens, je pense que je vais essayer de jeter un petit coup d'oeil, et non ce n'est pas pour "l'ecole", a mon stade on appelle ca la fac, mais je n'ai fais les piles qu'en ADA et c'etait beaucoup plus simple ( dans mes souvenirs en tout cas...)
