链表和动态分配受挫c++

以下是参考代码：

#include <iostream>
using namespace std;
class linkedList {
    struct listNode{ //a node of a list
        int value;
        struct listNode *next;
    };
    listNode *head;
    public:
    linkedList(){
        cout << "hello1n";
        head = NULL;
    };
    linkedList(listNode* a){
        cout << "hello2n";
        head = a;
    };
    ~linkedList();
    listNode* getHead() {return head;}
    void appendNode(int);
    //inline Search function due to unable to function outside of class definition
    listNode* rangeSearch(int a, int b){
            //listNode to search
            listNode *search = head;
            //listNode* toReturn = new listNode;
            //listNode to return list of values that are found within range
            linkedList *found = new linkedList;
            while(search){
                //if the current value is within range, then add to list
                if(search->value >= a && search->value <= b){
                    //append searched value onto found
                    found->appendNode(search->value);
                    //after appending, go to next value
                }
                search = search->next;
            }
            return found->getHead();
        }
    void display();
};

int main()
{
    cout << "Programmer  : nn";
    cout << "Description : n";
    linkedList* list = new linkedList;
    int x = 12;
    //values to search
    int s1 = 10, s2 = 14;
    // adds 2 to each number on list for 5 times 
    for(int i = 0; i < 5; i++){
        list->appendNode(x);
        x += 2;
    }
    //create something to hold pointer of found to be deleted when done using
    //print list
    cout << "Original set of numbers in linked list: ";
    list->display();
    cout << "nThe following are the values withing ranges: " << s1 << " and " << s2 << ":n";
    //EDITED:
    //list->rangeSearch(s1,s2);
    linkedList foundList(list->rangeSearch(s1,s2));
    foundList.display();
    //End of edit 6:40PM 7/18/13
    cout << "nHere are the original set of numbers in linked list (again): ";
    list->display();
    delete list;
    return 0;
}

void linkedList::appendNode(int newValue)
{
    listNode *newNode = new listNode();  // To point to a new node
    listNode *nodePtr;  // To move through the list
    // Allocate a new node and store newValue there.
    newNode->value = newValue;
    newNode->next = 0;
    // If there are no nodes in the list
    // make newNode the first node.
    if (!head)
        head = newNode;
    else  // Otherwise, insert newNode at end.
    {
        // Initialize nodePtr to head of list.
        nodePtr = head;
        // Find the last node in the list.
        while (nodePtr->next)
            nodePtr = nodePtr->next;
        // Insert newNode as the last node.
        nodePtr->next = newNode;
    }
}
void linkedList::display() {
    for(listNode* p = head; p != NULL; p = p->next)
        cout << p->value << ' ';
}
linkedList::~linkedList()
{
    cout << "ndestructor called";
    listNode *nodePtr;   // To traverse the list
    listNode *nextNode;  // To point to the next node
    // Position nodePtr at the head of the list.
    nodePtr = head;
    // While nodePtr is not at the end of the list...
    while (nodePtr != NULL)
    {
        // Save a pointer to the next node.
        nextNode = nodePtr->next;
        // Delete the current node.
        delete nodePtr;
        // Position nodePtr at the next node.
        nodePtr = nextNode;
    }
}

这里有几个问题。首先，为什么当我试图将rangeSearch成员函数放在类定义之外时，编译器会给出一个错误，说listNode*类型无法识别？

其次，这与析构函数有关。在这个程序中，创建了2个实例（list&found list），但只调用了1个析构函数。有人能解释一下原因吗？我的直觉告诉我，指向linkedList对象的动态分配指针没有被破坏。然而，我不知道为什么。我之所以必须使用动态分配的内存，主要是因为我想将指针传递回主函数。如果我不这样做，当rangeSearch退出时，指针将被传递回main，但指针的任何列表都将在之后被解构返回ptr；（假设ptr是指向rangeSearch中声明的linkedList的指针）这将导致我的程序崩溃，因为现在地址中什么都没有，我正试图调用。。。没有什么

和往常一样，我会感谢任何一个伟大的撒玛利亚人，他愿意教育我更多这方面的知识。