C++Talk.NET

J. KHOURY · Guest

Bonjour,

J'ai un petit problème avec un programme c++ que j'ai téléchargé sur le net.
Il concerne la liste chainée. J'utilise VC++ . j'ai modifié au niveau des
options l'option en mettant :

Not Using Precompiled Headers : Not Using Precompiled Headers

qd je compile il m'affiche l'erreur suivante:

error LNK2019: unresolved external symbol _main referenced in function
_mainCRTStartup

Debug/list.exe : fatal error LNK1120: 1 unresolved externals

il faut dire que le programme est constitué de deux fichiers : list.cpp et
list.h.

si je garde l'option par défaut j'ai une autre erreur de type

fatal error C1010: unexpected end of file while looking for precompiled
header directive

Ensuite j'ai recopié le list.h ds le list.cpp pour éviter de faire référence
à un fichier externe j'ai eu le même message.

Avez vous une idée?

Merci

Pierre Maurette · Guest

"J. KHOURY" <jkhoury (AT) free (DOT) fr> a écrit ...

Loïc Joly · Guest

J. KHOURY wrote:

J. KHOURY · Guest

Tu as raison, il n'y a pas de fonction main. comment faire avec cet exemple.
Je cherche un exemple sur la liste chaînée. comment je peux faire pour le
faire marcher?

fichier list.h

#ifndef _List_

#define _List_

template <class ElementType>

class List

{

protected:

// Structure pour une liste chainee avec

// un noeud initial "bidon".

struct Node {

ElementType Element;

Node *Next;

Node( ElementType E = 0, Node *N = NULL ):

Element( E ), Next( N ) {}

};

Node *Head;

Node *Current;

void Delete( );

List( List &Value );

public:

// Constructeur.

List( ) : Head( new Node ), Current( Head ) {}

// Destructeur.

virtual ~List( ) { Delete( ); }

// Operateurs et operations.

const List &operator = ( List &Value );

const List &operator ++ ( );

int operator ! ( ) const;

const ElementType &operator () ( ) const;

int Empty ( ) const

{ return Head -> Next == NULL; }

void First ( )

{ if( Head->Next != NULL ) Current = Head->Next; }

virtual void Header ( )

{ Current = Head; }

virtual int Find ( const ElementType &X );

virtual int Previous ( const ElementType &X );

int Present ( const ElementType &X );

virtual int Remove ( const ElementType &X );

virtual void Insert ( const ElementType &X );

// virtual void InsertFirst( const ElementType &X );

};

#endif

le fichier list.cpp

#include "list.h"

template <class ElementType>

void

List<ElementType>::

Delete( )

{

Node *P = Head->Next, *Tmp;

while( P != NULL ) {

Tmp = P->Next;

delete P;

P = Tmp;

}

delete Head;

}

// Avance le pointeur Current.

template <class ElementType>

inline const List<ElementType> &

List<ElementType>::

operator ++ ( )

{

if( Current != NULL )

Current = Current->Next;

return *this;

}

// Retrouve l'element pointe par Current.

// La valeur retrournee est indefinie si

// Current est NULL.

template <class ElementType>

inline const ElementType &

List<ElementType>::

operator () ( ) const

{

if( Current != NULL )

return Current->Element;

else

return Head->Element;

}

// Verifie si Current est non NULL.

template <class ElementType>

inline int

List<ElementType>::

operator ! ( ) const

{

return Current != NULL;

}

// Retourn TRUE et met Current a l'element cherche

// s'il est present.

template <class ElementType>

inline int

List<ElementType>::

Find( const ElementType &X )

{

Node *P;

for( P = Head->Next; P != NULL; P = P->Next )

if( P->Element == X ) {

Current = P;

return 1;

}

return 0;

}

// Retourne TRUE et met Current sur l'element

// qui precede X si present.

template <class ElementType>

inline int

List<ElementType>::

Previous( const ElementType &X )

{

Node *P;

for( P = Head->Next; P->Next != NULL; P = P->Next )

if( P->Next->Element == X ) {

Current = P;

return 1;

}

return 0;

}

// Insere l'element X apres l'element pointe par Current.

template <class ElementType>

void

List<ElementType>::

Insert( const ElementType &X )

{

Node *P = new Node( X, Current->Next );

if( P == NULL )

cout << "Out of space!" << endl;

else {

Current->Next = P;

Current = Current->Next;

}

}

// Retire X de la list.

// Retourne TRUE si succes.

template <class ElementType>

int

List<ElementType>::

Remove( const ElementType &X )

{

Node *ToDelete;

if( Previous( X ) ) {

ToDelete = Current->Next;

Current->Next = ToDelete->Next;

delete ToDelete;

return 1;

}

return 0;

}

// Replication d'une liste.

// Les pointeurs Current des deux listes

// pointent sur leur premier element.

template <class ElementType>

const List<ElementType> &

List<ElementType>::

operator = ( List<ElementType> &Value )

{

if( this == &Value ) // On ne se recopie pas!

return *this;

Delete(); // On delete la liste a affectee.

Current = Head = new Node;

for( Value.First(); !Value; ++Value ) {

Current->Next = new Node( Value(), Current->Next );

Current = Current->Next;

}

Current->Next = NULL;

First();

Value.First();

return *this;

}

"Loïc Joly" <loic.actarus.joly (AT) wanadoo (DOT) fr> a écrit dans le message de
news:c0v746$mlf$1 (AT) news-reader1 (DOT) wanadoo.fr...

Pierre Maurette · Guest

"J. KHOURY" <jkhoury (AT) free (DOT) fr> a écrit...