C++链表，尽量使用C++11

#pragma once
#include<memory>
#ifndef CHAINNODE_H
#define CHAINNODE_H
using std::make_shared;
using std::shared_ptr;

template <typename T>
struct chainNode
{
    T element;
    shared_ptr<chainNode> next;

    chainNode(const T &theElement)
    {
        element = theElement;
        next = nullptr;
    }

    chainNode(const T &theElement, const shared_ptr<chainNode<T>> theNext)
    {
        element = theElement;
        next = theNext;
    }
};
#endif // !CHAINNODE_H

#pragma once

#include"chainNode.h"
#include<memory>
#ifndef CHAIN_H
#define CHAIN_H
using std::shared_ptr;
using std::make_shared;

template<typename T>
class chain//下标从1开始
{
public:
    chain() {};
    chain(const T elementList[], const int leng);
    void insert(int pos, const T &theElement);
    void erase(const T &theElement);
    void output()const;
private:
    shared_ptr<chainNode<T>> firstNode; 
    int chainSize;
};


template<typename T>
chain<T>::chain(const T elementList[],const int leng)//链表长度至少为2
{
    firstNode = make_shared<chainNode<T>>(elementList[0]);
    chainSize = 1;
    auto pos(firstNode);
    for(int i = 1; i < leng; i++)
    {
        pos->next = make_shared<chainNode<T>>(elementList[i]);
        pos = pos->next;
        chainSize++;
    }
}

template<typename T>
void chain<T>::insert(int situ, const T &theElement)
{
    auto targetNode = make_shared<chainNode<T>>(theElement);
    if (situ == 1)
    {
        targetNode->next = firstNode;
        firstNode = targetNode;
        chainSize++;
        return;
    }
    situ-=2;
    auto fron(firstNode);
    while (situ && fron != nullptr)
    {
        fron = fron->next;
        situ--;
    }
    auto tail(fron->next);
    fron->next = targetNode;
    targetNode->next = tail;
    chainSize++;
    return;
}

template<typename T>
void chain<T>::erase(const T &theElement)
{
    if (firstNode->element == theElement)
    {
        firstNode = firstNode->next;
        chainSize--;
        return;
    }
    auto fron(firstNode);
    auto pos(fron->next);
    while (pos!=nullptr)
    {
        if (pos->element == theElement)
        {
            fron->next = pos->next;
            break;
        }
        fron = fron->next;
        pos = fron->next;
    }
    chainSize--;
}

template<typename T>
void chain<T>::output()const
{
    auto pos(firstNode);
    while (pos != nullptr)
    {
        cout << pos->element << ‘ ‘;
        pos = pos->next;
    }
    cout << endl;
}

#endif // !CHAIN_H

// chain2.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include"chain.h"
using std::cout;
using std::endl;



int main()
{
    double list[5] = { 2,4,6,8,10 };
    chain<double> chainList(list,5);//初始化
    chainList.output();
    chainList.insert(1, 1);
    chainList.insert(3, 3);
    chainList.output();
    chainList.erase(3);
    chainList.output();
    chainList.erase(1);
    chainList.output();

    getchar();
    return 0;
}