根据给定要求，模仿 STL list 的设计与实现 1）模仿 C++标准库（STL）中的双向列表（list），自己完成一个 list 的设计与实现 2）利用泛型编程，要求设计的 list 支持所有数据类型的数据处理，自定义链表节点的数据结构 3) list 能够实现元素遍历，即实现迭代器类，迭代器类能够实现*，++，--，==，！= 等运算符重载 4）所设计的 list 要实现构造函数、拷贝构造函数、析构函数、判空函数（empty）、获取 list 大小函数（size）、从指定位置插入函数（insert）、从 list 后面插入，删除元素(push_back，pop_back）、从list 前面插入、删除元素 （push_front，pop_front）、删除指定位置元素 (erase） 5) list 的排序函数（sort），交换函数（swap）可以选做 6）设计实现完成后，要提供测试代码，验证设计的正确性 7）鼓励设计和实现中使用 C++ 11 的新特性，也可以考虑自己将实现的list 进行动态库封装调用

好的，这是一个比较大的项目，需要一定的时间和精力来完成。我可以帮您提供一些思路和代码实现，但是具体的实现和测试还需要您自己完成。以下是一些基本的思路和代码实现：

1. 定义链表节点的数据结构

首先需要定义链表节点的数据结构，包括节点的值、前驱节点和后继节点。这里可以使用模板类来实现支持所有数据类型的数据处理。

template <typename T>
struct ListNode {
    T value;
    ListNode* prev;
    ListNode* next;
    ListNode(const T& v): value(v), prev(nullptr), next(nullptr) {}
};

2. 定义 list 类

定义 list 类，包括构造函数、拷贝构造函数、析构函数、判空函数、获取 list 大小函数等基本函数。其中，构造函数需要初始化头节点和尾节点，拷贝构造函数需要实现深拷贝，析构函数需要释放链表中所有节点的内存。

template <typename T>
class List {
public:
    List(): head(new ListNode<T>(T())), tail(head), length(0) {}
    List(const List<T>& other);
    ~List();
    bool empty() const;
    int size() const;
    void insert(ListNode<T>* node, const T& value);
    void push_back(const T& value);
    void pop_back();
    void push_front(const T& value);
    void pop_front();
    void erase(ListNode<T>* node);
    List<T>& operator=(const List<T>& other);
private:
    ListNode<T>* head;
    ListNode<T>* tail;
    int length;
};

3. 实现迭代器类

实现迭代器类，包括重载 *、++、--、==、!= 等运算符，以实现元素的遍历。

template <typename T>
class ListIterator {
public:
    ListIterator(ListNode<T>* node): current(node) {}
    T& operator*() const { return current->value; }
    ListIterator& operator++() { current = current->next; return *this; }
    ListIterator& operator--() { current = current->prev; return *this; }
    bool operator==(const ListIterator& other) const { return current == other.current; }
    bool operator!=(const ListIterator& other) const { return current != other.current; }
private:
    ListNode<T>* current;
};

4. 实现 list 类的各种函数

实现 list 类的各种函数，包括从指定位置插入函数、从 list 后面插入、删除元素(push_back，pop_back)、从 list 前面插入、删除元素（push_front，pop_front）、删除指定位置元素 (erase）等。

template <typename T>
void List<T>::insert(ListNode<T>* node, const T& value) {
    ListNode<T>* new_node = new ListNode<T>(value);
    new_node->prev = node->prev;
    new_node->next = node;
    node->prev->next = new_node;
    node->prev = new_node;
    ++length;
}

template <typename T>
void List<T>::push_back(const T& value) {
    insert(tail, value);
}

template <typename T>
void List<T>::pop_back() {
    if (tail != head) {
        ListNode<T>* node = tail;
        tail = node->prev;
        tail->next = nullptr;
        delete node;
        --length;
    }
}

template <typename T>
void List<T>::push_front(const T& value) {
    insert(head->next, value);
}

template <typename T>
void List<T>::pop_front() {
    if (head->next != tail) {
        ListNode<T>* node = head->next;
        head->next = node->next;
        node->next->prev = head;
        delete node;
        --length;
    }
}

template <typename T>
void List<T>::erase(ListNode<T>* node) {
    if (node != head && node != tail) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
        delete node;
        --length;
    }
}

template <typename T>
bool List<T>::empty() const {
    return length == 0;
}

template <typename T>
int List<T>::size() const {
    return length;
}

5. 实现 list 类的排序函数和交换函数

可以选做 list 类的排序函数和交换函数。排序函数可以使用快速排序、归并排序等算法实现，交换函数可以交换两个节点的值。

6. 编写测试代码

编写测试代码，验证设计的正确性。可以测试 list 类的各种函数、迭代器的使用、排序函数和交换函数的正确性等。

这是一个比较大的项目，需要一定的时间和精力来完成。如果您需要更详细的代码实现或者有其他问题，可以告诉我。