疑问疑问疑问

#include <iostream>
#include <string.h>
#include "./singlelist/singlelist.h"

using namespace std;
typedef struct{
    int idx;
    char name[64];
}ELEMENT2;


int main(int argv, char** argc)
{
    cout << "hello world" << endl;
    cout << "SingleList_main01" << endl;
    SingleList_main01();
    cout << "SingleList_main02" << endl;
    SingleList_main02();
    cout << "SingleList_main03" << endl;
    SingleList_main03();
    cout << "SingleList_main04" << endl;
//    SingleList_main04();

    SingleList<ELEMENT2> sList2;
    sList2.clear();

//    SingleList<int> sList;
//    sList.clear();

    return 0;
}

/* 单链表练习
 * 2022.04.01 20:14
*/


#include <iostream>
#include <string.h>
#include "singlelist.h"

using namespace std;

//template<typename T>
//SingleList<T>::SingleList(void)
//{
//    m_nodeHead = nullptr;
//    m_nodeTail = nullptr;
//    cnt = 0;
//    cout << "["<< __FILE__ << "|" << __LINE__  << "]" << "constructor!" << endl;
//}

//template<typename T>
//SingleList<T>::~SingleList(void)
//{
//    Node<T> *p = nullptr;
//
//    //遍历释放节点
//    while(nullptr != m_nodeHead)
//    {
//        p = m_nodeHead;
//        m_nodeHead = p->next;
//        delete p;
//        cout << "delete: " << p << endl;
//        p = nullptr;
//        m_nodeTail = nullptr;
//    }
//    cout << "["<< __FILE__ << "|" << __LINE__  << "]" << "deconstructor!" << endl;
//}

template<typename T>
int SingleList<T>::insertHead(const T& ele)
{
    Node<T> *p = nullptr;

    p = new Node<T>;
    memcpy(&p->ele, &ele, sizeof(T));
    //插入节点的next指向原来的首节点
    p->next = m_nodeHead;
    //旧的首节点为null,说明原来无节点，此时新的尾结点和新的首节点相同
    if(nullptr == m_nodeHead)
    {
        m_nodeTail = p;
    }
    //新的首节点为插入的节点
    m_nodeHead = p;
    cnt ++;
    return 0;
}

template<typename T>
int SingleList<T>::getHead(T& ele)
{
    if(nullptr == m_nodeHead)
    {
        return -1;
    }
    memcpy(&ele, m_nodeHead, sizeof(T));
    return 0;
}

template<typename T>
int SingleList<T>::deleteHead(void)
{
    Node<T> *p = nullptr;

    p = m_nodeHead;
    if(nullptr != p)
    {
        //新的首节点设为下一个节点
        m_nodeHead = p->next;
        //若新的首节点为null,说明无节点，尾结点也要设为null
        if(nullptr == m_nodeHead)
        {
            m_nodeTail = nullptr;
        }
        //释放首节点
        delete p;
        cnt --;
    }

    return 0;
}

template<typename T>
int SingleList<T>::insertTail(const T& ele)
{
    Node<T> *p = nullptr;

    p = new Node<T>;
    memcpy(&p->ele, &ele, sizeof(T));
    //尾结点不为null,则在旧的尾结点后面继续加，并将新的结点改为新加的节点
    if(nullptr != m_nodeTail)
    {
        m_nodeTail->next = p;
        m_nodeTail = p;
    }
    //尾结点为null,说明无节点，新插入的节点成为新的首节点和新的尾结点
    else
    {
        m_nodeTail = p;
        m_nodeHead = p;
    }
    cnt ++;    
}

template<typename T>
int SingleList<T>::getTail(T& ele)
{
    if(nullptr == m_nodeTail)
    {
        return -1;
    }
    memcpy(&ele, m_nodeTail, sizeof(T));
    return 0;
}

template<typename T>
int SingleList<T>::deleteTail(void)
{
    Node<T> *p = nullptr;

    //旧的首节点和尾结点相同，且不为null，说明原链表只有一个节点
    //则释放首节点，新的头节点和尾结点都为null
    if(m_nodeHead == m_nodeTail && nullptr != m_nodeTail)
    {
        delete m_nodeTail;
        m_nodeTail = nullptr;
        m_nodeHead = nullptr;
        cnt --;
    }
    //若原链表不止一个节点
    else if(nullptr != m_nodeTail)
    {
        p = m_nodeHead;
        //遍历，找到尾结点上一个节点，释放旧的尾结点，新的尾结点为旧的上一个节点
        while(nullptr != p && m_nodeTail != p->next)
        {
            p = p->next;
        }
        p->next = nullptr;
        delete m_nodeTail;
        m_nodeTail = p;
        cnt--;
    }

    return 0;
}

template<typename T>
int SingleList<T>::clear(void)
{
    Node<T> *p = nullptr;

    //从头遍历，依次释放
    while(nullptr != m_nodeHead)
    {
        p = m_nodeHead;
        m_nodeHead = p->next;
        delete p;
        cout << "delete: " << p << endl;
        p = nullptr;
    }
    m_nodeTail = nullptr;
    cout << "clear!" << endl;

    return 0;
}

template<typename T>
void SingleList<T>::print(void)
{

    Node<T> *p = m_nodeHead;
    cout << m_nodeHead << " " << m_nodeTail << endl;
    while(nullptr != p)
    {
//        cout << "<" << cnt << ">" << p << " " << p->ele  << endl;

        p = (Node<T> *)(p->next);
    }
    cout << endl;
}


int SingleList_main01()
{
    SingleList<int> sList;
    sList.insertHead(101);
    sList.print();
    sList.insertHead(102);
    sList.print();
    sList.insertHead(103);
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.deleteHead();
    sList.print();
    return 0;
}

int SingleList_main02()
{
    SingleList<int> sList;
    sList.insertTail(201);
    sList.print();
    sList.insertTail(202);
    sList.print();
    sList.insertTail(203);
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.insertHead(204);
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.deleteHead();
    sList.print();
    sList.insertHead(205);
    sList.print();
    sList.insertHead(206);
    sList.print();
    sList.insertHead(207);
    sList.print();
    return 0;
}
//typedef struct{
//    int idx;
//    char name[64];
//}ELEMENT2;

int SingleList_main03()
{
    SingleList<int> sList;
    sList.insertTail(301);
    sList.print();
    sList.insertTail(302);
    sList.print();
    sList.insertTail(303);
    sList.print();
    sList.deleteTail();
    sList.print();
    sList.deleteTail();
    sList.print();
    sList.deleteTail();
    sList.print();

    sList.insertHead(304);
    sList.print();
    sList.insertHead(305);
    sList.print();
    sList.insertHead(306);
    sList.print();

    sList.clear();
    sList.print();
}

int SingleList_main04()
{
//    SingleList<ELEMENT2> sList2;
}

#ifndef __SINGLELIST__H
#define __SINGLELIST__H

#include <iostream>
using namespace std;



#define nullptr NULL

/* 节点结构，next指针和T类型数据 */
template<typename T>
class Node{
public:
    T ele;
    Node *next;
    Node(){next=nullptr;}
};

/* 无头节点的单向链表 */
template<typename T>
class SingleList{
private:
    Node<T> *m_nodeHead;//首节点
    Node<T> *m_nodeTail;//尾结点
private:
    int cnt;
public:
    SingleList(void)
    {
        m_nodeHead = nullptr;
        m_nodeTail = nullptr;
        cnt = 0;
        cout << "["<< __FILE__ << "|" << __LINE__  << "]" << "constructor!" << endl;
    }
    ~SingleList(void)
    {
        Node<T> *p = nullptr;

        //遍历释放节点
        while(nullptr != m_nodeHead)
        {
            p = m_nodeHead;
            m_nodeHead = p->next;
            delete p;
            cout << "delete: " << p << endl;
            p = nullptr;
            m_nodeTail = nullptr;
        }
        cout << "["<< __FILE__ << "|" << __LINE__  << "]" << "deconstructor!" << endl;

    }
    int insertHead(const T& ele);//头插
    int getHead(T& ele);//获取首节点
    int deleteHead(void);//头删
    int insertTail(const T& ele);//尾插
    int getTail(T& ele);//获取尾节点
    int deleteTail(void);//尾删
    int clear(void);//清除
    void print(void);//遍历打印节点
};

int SingleList_main01();
int SingleList_main02();
int SingleList_main03();
int SingleList_main04();


#endif