-------------------------------
Réponse au message :
Merde j'avais cru que c'était avec template :(
Et pour le code java j'ai foiré lors d'un copier collé. Mais sinon le reste est du C++.
c'est de ma faute j'avais mal lu :(
-------------------------------
> j'espère que c'est une blague
trinitacs?
> on demande du code C++ sans templates
> et tu réponds du code Java avec templates (alors que Java ne les supporte d'ailleurs pas)
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> >
> >
> >
> >
> > -------------------------------
> > Réponse au message :
> > J'ai foiré dans la première source, je te la redonne:
> >
> > // Fig. 15.3: Liste.h
> > // D?finition du mod?le de classe Liste.
> > #ifndef LISTE_H
> > #define LISTE_H
> >
> > #include <iostream.h>
> > #include <assert.h>
> > #include "listnd.h"
> >
> > template< class TYPENOEUD >
> > class Liste {
> > public:
> > Liste(); // Constructeur.
> > ~Liste(); // Destructeur.
> > void insererEnTete( const TYPENOEUD & );
> > void insererEnQueue( const TYPENOEUD & );
> > bool retirerDeTete( TYPENOEUD & );
> > bool retirerDeQueue( TYPENOEUD & );
> > bool estVide() const;
> > void afficher() const;
> > private:
> > NoeudDeListe< TYPENOEUD > *ptrPremier; // Pointeur vers premier noeud.
> > NoeudDeListe< TYPENOEUD > *ptrDernier; // Pointeur vers dernier noeud.
> >
> > // Fonction utilitaire d'allocation d'un nouveau noeud.
> > NoeudDeListe< TYPENOEUD > *obtenirNouveauNoeud( const TYPENOEUD & );
> > };
> >
> > // Constructeur par défaut.
> > template< class TYPENOEUD >
> > Liste< TYPENOEUD >::Liste() : ptrPremier( 0 ), ptrDernier( 0 ) { }
> >
> > // Destructeur.
> > template< class TYPENOEUD >
> > Liste< TYPENOEUD >::~Liste()
> > {
> > if ( !estVide() ) { // La liste n'est pas vide.
> > cout << "Destruction des noeuds ...\n";
> >
> > NoeudDeListe< TYPENOEUD > *ptrCourant = ptrPremier, *ptrTemp;
> >
> > while ( ptrCourant != 0 ) { // D?truire les noeuds restants.
> > ptrTemp = ptrCourant;
> > cout << ptrTemp->donnee << '\n';
> > ptrCourant = ptrCourant->ptrSuivant;
> > delete ptrTemp;
> > }
> > }
> >
> > cout << "Tous les noeuds sont d?truits.\n\n";
> > }
> >
> > // Ins?rer un noeud en t?te de la liste.
> > template< class TYPENOEUD >
> > void Liste< TYPENOEUD >::insererEnTete( const TYPENOEUD &valeur )
> > {
> > NoeudDeListe< TYPENOEUD > *nouveauPtr = obtenirNouveauNoeud( valeur );
> >
> > if ( estVide() ) // La liste est vide.
> > ptrPremier = ptrDernier = nouveauPtr;
> > else { // La liste n'est pas vide.
> > nouveauPtr->ptrSuivant = ptrPremier;
> > ptrPremier = nouveauPtr;
> > }
> > }
> >
> > // Ins?rer un noeud ? la queue de la Liste
> > template< class TYPENOEUD >
> > void Liste< TYPENOEUD >::insererEnQueue( const TYPENOEUD &valeur )
> > {
> > NoeudDeListe< TYPENOEUD > *nouveauPtr = obtenirNouveauNoeud( valeur );
> >
> > if ( estVide() ) // La liste est vide.
> > ptrPremier = ptrDernier = nouveauPtr;
> > else { // La liste n'est pas vide.
> > ptrDernier->ptrSuivant = nouveauPtr;
> > ptrDernier = nouveauPtr;
> > }
> > }
> >
> > // Supprimer un noeud de la t?te de la liste.
> > template< class TYPENOEUD >
> > bool Liste< TYPENOEUD >::retirerDeTete( TYPENOEUD &valeur )
> > {
> > if ( estVide() ) // La liste est vide.
> > return false; // chec suppression.
> > else {
> > NoeudDeListe< TYPENOEUD > *ptrTemp = ptrPremier;
> >
> > if ( ptrPremier == ptrDernier )
> > ptrPremier = ptrDernier = 0;
> > else
> > ptrPremier = ptrPremier->ptrSuivant;
> >
> > valeur = ptrTemp->donnee; // Donn?e en cours de suppression.
> > delete ptrTemp;
> > return true; // R?ussite suppression.
> > }
> > }
> >
> > // Supprimer un noeud de la queue de la liste.
> > template< class TYPENOEUD >
> > bool Liste< TYPENOEUD >::retirerDeQueue( TYPENOEUD &valeur )
> > {
> > if ( estVide() )
> > return false; // chec de la suppression.
> > else {
> > NoeudDeListe< TYPENOEUD > *ptrTemp = ptrDernier;
> >
> > if ( ptrPremier == ptrDernier )
> > ptrPremier = ptrDernier = 0;
> > else {
> > NoeudDeListe< TYPENOEUD > *ptrCourant = ptrPremier;
> >
> > while ( ptrCourant->ptrSuivant != ptrDernier )
> > ptrCourant = ptrCourant->ptrSuivant;
> >
> > ptrDernier = ptrCourant;
> > ptrCourant->ptrSuivant = 0;
> > }
> >
> > valeur = ptrTemp->donnee;
> > delete ptrTemp;
> > return true; // R?ussite suppression.
> > }
> > }
> >
> > // La liste est-elle vide ?
> > template< class TYPENOEUD >
> > bool Liste< TYPENOEUD >::estVide() const
> > { return ptrPremier == 0; }
> >
> > // Retourner un pointeur vers un noeud nouvellement allou?.
> > template< class TYPENOEUD >
> > NoeudDeListe< TYPENOEUD > *Liste< TYPENOEUD >::obtenirNouveauNoeud(
> > const TYPENOEUD &valeur )
> > {
> > NoeudDeListe< TYPENOEUD > *ptr =
> > new NoeudDeListe< TYPENOEUD >( valeur );
> > assert( ptr != 0 );
> > return ptr;
> > }
> >
> > // Afficher le contenu de la liste.
> > template< class TYPENOEUD >
> > void Liste< TYPENOEUD >::afficher() const
> > {
> > if ( estVide() ) {
> > cout << "La liste est vide.\n\n";
> > return;
> > }
> >
> > NoeudDeListe< TYPENOEUD > *ptrCourant = ptrPremier;
> >
> > cout << "La liste contient : ";
> >
> > while ( ptrCourant != 0 ) {
> > cout << ptrCourant->donnee << ' ';
> > ptrCourant = ptrCourant->ptrSuivant;
> > }
> >
> > cout << "\n\n";
> > }
> >
> > #endif
> >
> > -------------------------------
> >
> > >
> > >
> > >
> > >
> > > -------------------------------
> > > Réponse au message :
> > > Tu veux donc une liste chaînée qui n'utilise pas la STL et qui soit template afin d'utiliser plusieurs types d'objets.
> > >
> > > Des exemples de liste chaînées il y en a un bon nombre mais template beaucoup moins.
> > >
> > > Vla un code de deux fichiers:
> > >
> > > // Copyright J-f Mitchell, this litle peace of code is a great
> > > // tutorial for swing begigner.
> > >
> > >
> > > import java.awt.*;
> > > import java.awt.event.*;
> > > import javax.swing.*;
> > >
> > > public class JavaApp {
> > > JFrame frame1;
> > > JButton command1;
> > > JTextField text1; //Declaring variables in class to able to use it in the whole class.
> > > JPanel panel1;
> > > JButton command2;
> > >
> > >
> > > public JavaApp() {
> > >
> > > frame1 = new JFrame("Put your title here"); //Main frame
> > > frame1.setSize(50, 50);
> > > command1 = new JButton("Button 1"); // creating control from declared variable in the class
> > > text1 = new JTextField(20);
> > > panel1 = new JPanel();
> > > command2 = new JButton("Button 2");
> > >
> > >
> > > command1.setMnemonic(KeyEvent.VK_I); //This is an event listener without the implements in the class, I like this method!
> > > command1.addActionListener(new ActionListener() {
> > > public void actionPerformed(ActionEvent e) {
> > > text1.setText("Button 1!");
> > > }
> > > });
> > >
> > >
> > > command2.setMnemonic(KeyEvent.VK_I); // listener for the second button
> > > command2.addActionListener(new ActionListener() {
> > > public void actionPerformed(ActionEvent e) {
> > > text1.setText("Button 2!");
> > > }
> > > });
> > >
> > >
> > > panel1.setLayout(new FlowLayout());
> > > panel1.add(text1);
> > > panel1.add(command1); //adding components to pane, you need this to be able to see ure component,
> > > panel1.add(command2);
> > >
> > > frame1.getContentPane().add(panel1, BorderLayout.CENTER); //add my pane to my frame
> > >
> > > // Exit when the window is closed.
> > > frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
> > >
> > > // show the frame!
> > > frame1.pack();
> > > frame1.setVisible(true);
> > > }
> > >
> > >
> > > public static void main(String[] args) {
> > > // set the look and feel
> > > try {
> > > UIManager.setLookAndFeel(
> > > UIManager.getCrossPlatformLookAndFeelClassName()); //getting the java swing look
> > > } catch(Exception e) {}
> > >
> > > JavaApp javaapp = new JavaApp(); // tell the program to show up the frame by calling my GUI function
> > >
> > > }
> > > }
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > > // Fig. 15.3: listnd.h
> > > // D?finition du mod?le NoeudDeListe
> > > #ifndef LISTND_H
> > > #define LISTND_H
> > >
> > > template< class TYPENOEUD > class Liste; // D?claration ult?rieure.
> > >
> > > template<class TYPENOEUD>
> > > class NoeudDeListe {
> > > friend class Liste< TYPENOEUD >; // Faire de Liste un ami.
> > > public:
> > > NoeudDeListe( const TYPENOEUD & ); // Constructeur.
> > > TYPENOEUD obtenirDonnee() const; // Retour donnee du noeud.
> > > private:
> > > TYPENOEUD donnee; // Donn?e.
> > > NoeudDeListe< TYPENOEUD > *ptrSuivant; // Noeud suivant dans liste.
> > > };
> > >
> > > // Constructeur.
> > > template<class TYPENOEUD>
> > > NoeudDeListe< TYPENOEUD >::NoeudDeListe( const TYPENOEUD &info )
> > > : donnee( info ), ptrSuivant( 0 ) { }
> > >
> > > // Retour d'une copie de la donn?e du noeud.
> > > template< class TYPENOEUD >
> > > TYPENOEUD NoeudDeListe< TYPENOEUD >::obtenirDonnee() const { return donnee; }
> > >
> > > #endif
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > > Si tu veux tu peux regarder ma source qui utilise des listes chaînées (mais pas template). Tu auras des exemple des manipulations pour déplacer un noeud vers la fin ou au début etc....
> > > -------------------------------
> > >
> > > > Bonjour,
> > > >
> > > > je cherche un exemple de liste chainée (sans STL: ni vector ni template) en
> > > > C++ (pas en C) permettant de chainer des objets héterogenes (par exemple 2
> > > > classes A et B (B dérivant de A)).
> > > >
> > > > Si quelqu'un a ca en stock ca m'aiderait bien (google me donne que du STL).
> > > >
> > > > genre :
> > > >
> > > > class A {...}
> > > > class B : public A {...}
> > > >
> > > > et une classe de liste chainée
> > > > class ListeChainee
> > > > {
> > > > ...
> > > >
> > > > public:
> > > > void add(...);
> > > > }
> > > >
> > > > int main (void)
> > > > {
> > > > ListeChainee *LC = new ListeChainee();
> > > > A a;
> > > > B b;
> > > > LC.add (a);
> > > > LC.add (b);
> > > > }
> > > >
> > > > un truc dans le genre ca serait parfait. J'ai bien essayé de toutes les
> > > > facons possibles, mais je finirai suerment a l'asile avant d'avoir trouver
> > > > la moindre solution correcte (sans bidouille).
> > > >
> > > > D'avance merci :o)
> > > >
> > >
> >
>