Optimizing a linked list I wrote a linked list class and don't know how to optimize it, please suggest some ideas for optimizing and fixing possible memory leaks.
#define indexTooLarge -1
template &lt;typename T&gt;
class LincedList
{
public:
    LincedList(){}
    template&lt;typename... Types&gt;
    LincedList(T value,Types... values) :  LincedList(values...)
    {
        push_front(value);
    }
    LincedList(T value)
    {
        push_front(value);
    }
    ~LincedList()
    {
        clear();
    }
    void push_back(T value_a)
    {
        if(tail == nullptr)
        {
            tail = new Node(nullptr,value_a);
            head = tail;
            m_size++;
            return;
        }
        tail-&gt;next = new Node(nullptr,value_a);
        tail = tail-&gt;next;
        m_size++;
    }
    void push_front(T value_a)
    {
        if(head == nullptr)
        {
            head = new Node(nullptr,value_a);
            tail = head;
            m_size++;
            return;
        }
        head = new Node(head,value_a);
        m_size++;
    }
    void clear()
    {
        Node *buffer;
        for(int i = 0;i&lt;m_size;i++)
        {
            buffer = head;
            head = head-&gt;next;
            delete buffer;
        }
        m_size = 0;
    }
    void remove(unsigned int index)
    {
        if(index &gt;= m_size)
            throw indexTooLarge;
        Node *currectNode = head;
        for(int i = 0; i &lt; index-1;i++)
            currectNode = currectNode-&gt;next;
        Node* buffer = currectNode-&gt;next;
        currectNode-&gt;next = currectNode-&gt;next-&gt;next;
        delete buffer;
        m_size--;
    }
    void remove(unsigned int index,unsigned int lenght)
    {
        if(index+lenght &gt;= m_size)
            throw indexTooLarge;
        Node *currectNode = head;
        for(int i = 0; i &lt; index-1; i++)
            currectNode = currectNode-&gt;next;
        Node* buffer = currectNode;
        currectNode = currectNode-&gt;next;
        for(int i = 0; i &lt; lenght; i++ )
        {
            Node* buffer2 = currectNode;
            currectNode = currectNode-&gt;next;
            delete buffer2;
        }
        buffer-&gt;next = currectNode;
        m_size -= lenght;
    }
    T&amp; operator[](unsigned const int &amp;index)
    {
        if(index &gt;= m_size)
            throw indexTooLarge;
        if(index == m_size-1)
            return tail-&gt;value;
        Node *currectNode = head;
        for(unsigned int i = 0; i &lt; index;i++)
            currectNode = currectNode-&gt;next;
        return currectNode-&gt;value;
    }
    void operator=(const LincedList &amp;C1)
    {
        head-&gt;value = C1.head-&gt;value;
        Node *currectNode = new Node(nullptr,C1[1]);
        Node *C1CurrectNode = C1[1];
        head-&gt;next = currectNode;
        for(int i = 2; i &lt; m_size; i++)
        {
            C1CurrectNode = C1CurrectNode-&gt;next;
            currectNode-&gt;next = new Node(nullptr,C1CurrectNode-&gt;value);
            currectNode = currectNode-&gt;next;
        }
        tail-&gt;value = C1.tail-&gt;value;
    }
    unsigned int size()
    {
        return m_size;
    }
private:
    struct Node
    {
         Node* next;
         T value;
         Node(Node* next_a, T value_a) : next(next_a) , value(value_a)
         {}
    };
    unsigned int m_size = 0;
    Node* head = nullptr;
    Node* tail = nullptr;
}; 

#include &lt;iostream&gt;
int main()
{
    LincedList&lt;int&gt; ll(0,1,2,3);
    std::cout &lt;&lt; ll[1] &lt;&lt; std::endl; //writes to console 1
    ll.remove(1); //removes the element at index 1
    std::cout &lt;&lt; ll[1] &lt;&lt; std::endl; //writes to console 2
    ll.push_back(4);//adds to the end 4
    ll.push_front(5);//adds 5 to the beginning
    std::cout &lt;&lt; ll.size() &lt;&lt; std::endl; //writes to console 5
    ll.remove(1,2); //remove all 2 to 3 elements
    std::cout &lt;&lt; ll[1] &lt;&lt; std::endl ; //writes to console 3
    return  0;
}
In addition to what Reinderien posted:
Look at std::forward_list
Your linked list is a single-linked list, the closes equivalent in the standard library is std::forward_list. You will notice from the documentation of std::forward_list that it doesn't implement a push_back(), and its erase() function only takes iterators, not indices. All this is to keep this data structure light and focused only on the properties that a single-linked list has: inserting and removing at the head is fast, and you can iterate over it in one direction. There is no operator[] overload.
Slower operations, like finding the node at a given index, are left to other functions such as std::advance(). And this makes it clear that if you want to do something like access random elements, you are better off using a different data structure, such as a std::vector.
Spelling
There are some spelling errors in your code:

LincedList -&gt; LinkedList
currectNode -&gt; currentNode (and some variants)

Maybe English is not your native language, that's fine. There are some tools that can help you find and fix common spelling errors in source code, like codespell. Consider running them on your code from time to time.
Don't do bounds checking
Well, you asked how to improve performance.
In C++ it is normal for standard containers to not do any bounds checking. The burden of bounds checking is placed on the caller. This avoids some overhead every time your functions are called.
Not throwing exceptions also allows code using your class to be compiled without exceptions enabled, which can have various benefits.