请教各位，能否改一下这个程序？（链表）

[cssupernet]

这段程序是介绍链表的一些基础知识。想修改一下程序，但不知该怎么办？
1）主函数中switch( choice ) //输入一个小数则会死循环？
2）List< NODETYPE > :: ~List(){　.... }//这一析构函数中原本是从链表的开头删除，如果要改成从链表的末尾删除应该怎样修改呢？


谢谢！


程序包括三个文件(1、listnd.h; 2、list.h; 3、大学教程p547.cpp）

1、
//LISTND_H

#ifndef LISTND_H
#define LISTND_H

template< class NODETYPE > class List;//declaration

template< class NODETYPE >
class ListNode {
friend class List< NODETYPE >;

public:
ListNode( const NODETYPE & );
NODETYPE getData() const ;

private:
NODETYPE data;
ListNode< NODETYPE > *nextPtr;

};


template< class NODETYPE >
ListNode< NODETYPE > :: ListNode ( const NODETYPE &info )
: data( info ), nextPtr( 0 ) { }

template< class NODETYPE >
NODETYPE ListNode< NODETYPE > :: getData() const { return data; }

#endif

[cssupernet]

jp1984(毛咏洁) :
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

谢谢，能否帮忙把那一小段程序写一写？

[cssupernet]

2、list.h

//list.h


#ifndef LIST_H
#define LIST_H

#include <iostream.h>
#include <assert.h>
#include "listnd.H"

template< class NODETYPE >
class List {
public:
List();
~List();
void insertAtFront( const NODETYPE &);
void insertAtBack( const NODETYPE & );
bool removeFromFront( NODETYPE & );
bool removeFromBack( NODETYPE & );
bool isEmpty() const;
void print() const ;

private:
ListNode< NODETYPE > *firstPtr;
ListNode< NODETYPE > *lastPtr;

ListNode< NODETYPE > *getNewNode( const NODETYPE & );


};
template< class NODETYPE >
List< NODETYPE > ::List() : firstPtr( 0 ) , lastPtr ( 0 ) { }



template< class NODETYPE >
List< NODETYPE > :: ~List(){
if ( !isEmpty () ){
cout << "Destroying nodes ...\n";

ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;

while( currentPtr != 0 ) {
tempPtr = currentPtr;
cout << tempPtr->data << endl;
currentPtr = currentPtr->nextPtr; //改成从后往前删，怎办
delete tempPtr;
}
}

cout << "All nodes destroyed\n\n";
}


template< class NODETYPE >
void List< NODETYPE > ::insertAtFront( const NODETYPE &value ){
ListNode< NODETYPE > *newPtr = getNewNode( value );

if ( isEmpty())
firstPtr = lastPtr = newPtr;
else {
newPtr->nextPtr = firstPtr;
firstPtr = newPtr;
}

}

template< class NODETYPE >
void List< NODETYPE > :: insertAtBack( const NODETYPE &value ){
ListNode< NODETYPE > *newPtr = getNewNode( value );

if ( isEmpty( ) )
firstPtr = lastPtr = newPtr;
else{
lastPtr->nextPtr = newPtr;
lastPtr = newPtr;
}
}


template< class NODETYPE >
bool List< NODETYPE > ::removeFromFront( NODETYPE &value ){
if ( isEmpty() )
return false;
else{
ListNode< NODETYPE > *tempPtr = firstPtr;

if( firstPtr == lastPtr )
firstPtr = lastPtr = 0;
else
firstPtr = firstPtr->nextPtr;

value = tempPtr->data;
delete tempPtr;
return true;
}
}

template< class NODETYPE >
bool List< NODETYPE > ::removeFromBack( NODETYPE &value ){
if ( isEmpty () )
return false;
else {
ListNode< NODETYPE > *tempPtr = lastPtr;

if ( firstPtr == lastPtr )
firstPtr = lastPtr = 0;
else {
ListNode< NODETYPE > *currentPtr = firstPtr;

while ( currentPtr->nextPtr != lastPtr )
currentPtr = currentPtr->nextPtr;

lastPtr = currentPtr;
currentPtr->nextPtr = 0;
}

value = tempPtr->data ;
delete tempPtr;
return true;
}

}

template< class NODETYPE >
bool List< NODETYPE > ::isEmpty()const
{ return firstPtr == 0; }


template< class NODETYPE >
ListNode< NODETYPE > *List< NODETYPE > ::getNewNode( const NODETYPE &value ){
ListNode< NODETYPE > *ptr =
new ListNode< NODETYPE >(value);
assert( ptr != 0 );
return ptr;
}


template< class NODETYPE >
void List< NODETYPE >::print() const {
if ( isEmpty() ){
cout << "The list is empty\n\n";

return;
}

ListNode< NODETYPE > *currentPtr = firstPtr;

cout << "The list is: ";

while ( currentPtr != 0 ) {
cout << currentPtr->data << ' ';
currentPtr = currentPtr->nextPtr;
}

cout << endl;
}


#endif

[cssupernet]

3、大学教程P547.cpp

#include <iostream.h>
#include "list.h"

template< class T >
void testList ( List< T > &listObject, const char *type ){
cout << "Testing a List of " << type << " values\n";

instruction();
int choice;
T value ;

do {
cout << "Please select one from 1~5: ";
cin >> choice;

　　　　switch( choice ) { //如果输入一个小数，则会死循环，能否解决这个异常
case 1:
cout << "Enter " << type << ": ";
cin >> value;
listObject.insertAtFront( value );
listObject.print();
break;

case 2:
cout << "Enter " << type << ": ";
cin >> value;
listObject.insertAtBack(value);
listObject.print();
break;

case 3:
if ( listObject.removeFromFront ( value ))
cout << value << " removed from list\n";

listObject.print();
break;

case 4:
if ( listObject.removeFromBack(value))
cout << value << " removed from list\n";

listObject.print();
break;
default:
cout << "Pleast input a number amont 1~5:\n";
}
}while ( choice != 5 );// input 5 to end list processing

cout << "Enter list test\n\n";
}


void instruction(){
cout << "Enter one of the following:\n"
<< " 1 to insert at beginning of list\n"
<< " 2 to insert at end of list\n"
<< " 3 to delete from beginning of list\n"
<< " 4 to delete from end of list\n"
<< " 5 to end list processing\n";
}

int main(){
List< int > integerList;
testList( integerList, " integer" );

List< float > floatList;
testList( floatList, " float " );

return 0;
}

[vconan]

default: //这个里面应该包括输入5吧，所以还要一个case 5:
cout << "Pleast input a number amont 1~5:\n";
这里加个break;试试~~

没调试的，随便看了下~~

[cssupernet]

给：vconan(名侦探柯南）

我试了一下，不是这样的。
不过依然十分感觉。

[cssupernet]

给：vconan(名侦探柯南）

我试了一下，不是这样的。
不过依然十分　　感谢　　。

[biliky]

switch 只能适用于整数变量或能用于整数运算的字符变量。

[biliky]

switch （choice) 中的choice 只能适用于整数变量或能用于整数运算的字符变量。

[cssupernet]

对啊，我知道　switch(choice) 中的choice 只能适用于整数变量或运算

但是程序中如果误输入了　小数　怎么解决？


能否自己写一个异常处理程序，处理这个异常？

[cssupernet]

另外，如果链表的删除函数　需要改成　从后往前删　怎么解决　？

[jp1984]

cssupernet(小石) ：
另外，如果链表的删除函数　需要改成　从后往前删　怎么解决　？
*********************************************************************************
双向链表没有教过？？你可以设定一个*last指向链表最后一个节点，就可以拉啊。。^_^。 顺便教你个新的，把尾节点指向头节点就成了循环链表。。

上面的程序没有看，实在太长了，数据结构不要看那本书啊。 。以后要学的饿。

[NOldkiller]

实弟，我是贺，不好意思，刚看到邮件.
(1)自己定义两个函数
inline long round(double d)
{
return (long)(d+0.5);
}
inline int round(float f)
{
return (int)(d+0.5);
}
然后你的switch可写成:
switch(round(choice));
或者直接写成：switch((int)(choice+0.5))
(2)
因为你在此List实现为单向链表，如果从后往前删，则每删除一个结点，则都要从首结点进行遍历到倒数第二个结点，删除最后一个结点后，再将倒数第二个结点设为新的尾结点，这样做，好像没必要吧!^_^，即使增加了复杂性效率又降低了，当然如果是双向链表则另当别论。
template< class NODETYPE >
List< NODETYPE > :: ~List(){
if ( !isEmpty () ){
cout << "Destroying nodes ...\n";

ListNode< NODETYPE > *tempPtr;

while( lastPtr != 0 ) {
tempPtr = firstPtr;
while((tempPtr!=0)&&(tempPtr->next != lastPtr))
tempPtr = tempPtr->next;
cout<<lastPtr->data<<endl;
delete lastPtr;
lastPtr = tempPtr;
}
}

cout << "All nodes destroyed\n\n";
}