首先，operator+不应该修改当前对象，它不应该返回一个向量，而应该返回一个新的String<T>，它应该是const。
你的char,int构造函数没有添加一个空终结符。也许这是故意的，但是我改变了它，因为我正在使用那个构造函数。此外，我删除了移动构造函数，因为它还不需要。在它的实现中，你把nullptr赋给了vector，这是错误的。你不需要实现移动构造函数，你可以声明它为=default;，这也是我对复制构造函数所做的，因为编译器生成的复制构造函数和你自己写的一样好（或者更好）。
然后，在你的代码中没有+对应'e'+String。当作为成员实现时，this总是左操作数。你可以把它作为自由函数实现。

#include <iostream>
#include <vector>

template<class T>
class String {   
public:
    std::vector<T> ptr_string;
    String() { ptr_string.push_back('\0'); }
    String(const String& other) = default;
    String(T symbol, int n) {    
        for (int i = 0; i < n; i++) {
            ptr_string.push_back(symbol);            
        }
        ptr_string.push_back('\0');        
    }
    int getLength() const {
        return ptr_string.size();
    }
    void printString() const {
        int i = 0;
        for (int i = 0; i < ptr_string.size(); i++) {
            std::cout << ptr_string[i];            
        }
        std::cout << std::endl;
    }
    template<typename T2>
    auto operator+( T2 b) const { 
        String res = *this;
        res.ptr_string.push_back(b);
        return res;
    }
    auto operator+( String const& a) {
        String res = *this;
        for (const auto& c : a.ptr_string) res.ptr_string.push_back(c);
        return res;
    }
};

template<typename T2,typename T>
auto operator+(const T2& b,const String<T>& a) { 
        return String<T>(b,1) + a;
}

int main() {
    String<char> P = String<char>( 'P', 10);
    auto Y = P + 'e';
    P.printString();
    Y.printString();
    auto Z = 'e' + P;
    P.printString();
    Z.printString();

}

Demo
这只是对你代码的最小改动。我实际上也会把类外的其他操作符实现为自由函数。char,int构造函数中的循环应该用适当的向量构造函数替换，也许还有更多可以改进的地方。关于操作符重载的更多信息，我推荐你参考https://en.cppreference.com/w/cpp/language/operators和What are the basic rules and idioms for operator overloading?

我不认为你的赋值真的涵盖了现实生活中发生的场景。它充满了代码的味道。正如@463035818_is_not_a_number提到的运算符+通常不修改当前对象。但它在技术上是可能的，见下文。向量并不意味着“push_front”，避免“push_front "向量作为一个一般规则（这里，我使用双端队列作为ex）。

#include <deque>
#include <iostream>
#include <string>

template<class T>
struct ConcatenableDeq
{
    std::deque<T> _deq;

    ConcatenableDeq(std::deque<T> deq) : _deq(deq) {};
         
    void print() const
    {
        for (const auto& e : this->_deq)
            std::cout << e << " ";
        std::cout << std::endl;
    }

    friend void operator+(ConcatenableDeq<T>& cd, const T& v)
    {
        cd._deq.push_back(v);
    }

    friend void operator+(const T& v, ConcatenableDeq<T>& cd)
    {
        cd._deq.push_front(v);
    }
};

int main(int argc, char* argv[])
{
    ConcatenableDeq<char> cd({ '1', '2', '3' });

    cd.print();
    cd + '4';
    cd.print();
    '0' + cd;
    cd.print();

    // output:
    // 1 2 3
    // 1 2 3 4
    // 0 1 2 3 4
}