Как определить операции вычитания, больше или меньше в типе char, какие ошибки в программе

#include "stdafx.h"
#include <iostream>
using namespace std;
 
template <class T>
class Tvector
{
public:
    int N;
    T *A;
public:
    Tvector();
    Tvector(unsigned);
    Tvector(unsigned, const T&);
    Tvector(const Tvector<T>&);
    ~Tvector();
    T& operator[](unsigned) const;
    operator unsigned() const;
    const bool operator==(const Tvector<T>&) const;
    const bool operator!=(const Tvector<T>&) const;
    template <class T> friend ostream & operator <<(ostream &, const Tvector <T> &);
    template <class T> friend istream & operator >> (istream &, Tvector <T> &);
    const Tvector<T> & operator=(const T&);
    const Tvector<T>& operator=(const Tvector<T>&);
};
 
 
template<class T>
Tvector<T>::Tvector() :A(NULL), N(0) {}
template<class T>
Tvector<T>::Tvector(unsigned n) : N(n) { A = new T[n]; if (A == NULL) { cout << "error"; exit(2); } }
template<class T>
Tvector<T>::Tvector(unsigned n, const T&z) : N(n)
{
    cout << "Tvector(unsigned n, const T&z)" << endl;
    A = new T[n]; if (A == NULL) { cout << "error"; exit(2); }
    for (unsigned i = 0; i<N; ++i) A[i] = z;
}
template<class T>
Tvector<T>::Tvector(const Tvector<T>&z) : N(z.N) { A = new T[N]; if (A == NULL) { cout << "error"; exit(2); } for (unsigned i = 0; i<N; ++i) A[i] = z.A[i]; }
 
template<class T> Tvector<T>::~Tvector() { if (A != NULL) delete[]A; }
 
template<class T>
Tvector<T>::operator unsigned() const { return N; }
 
template <class T>
T& Tvector<T>::operator [](unsigned i) const
{
    if (A == NULL) { cout << "ERROR\tNULL" << endl; system("pause"); exit(2); }
    if (i >= N) { cout << "ERROR\t" << endl;  exit(2); }
    else return A[i];
}
 
template <class T>
const Tvector<T> & Tvector<T>::operator=(const T& z)
{
    if (A == NULL) { N = 1; A = new T[1]; A[0] = z; }
    else for (unsigned i = 0; i < N; ++i)
    {
        A[i] = z;
    }
    return *this;
}
 
template <class T>
const Tvector<T> & Tvector<T>::operator=(const Tvector<T> &z)
{
    N = z.N;
    delete[] A;
    A = new T[N];
    for (unsigned i = 0; i < N; ++i)
    {
        A[i] = z.A[i];
    }
    return *this;
}
 
 
template <class T>
const bool Tvector<T>::operator==(const Tvector<T>&z) const
{
    if (A == NULL) { cout << "ERROR"; exit(2); }
    else
    {
        if (N == z.N)
        {
            for (unsigned i = 0; i<N; ++i)
            {
                if (A[i] != z.A[i]) { return 0; }
            }
            return 1;
        }
        else return 0;
    }
}
 
template <class T>
const bool Tvector<T>::operator!=(const Tvector<T>&z) const
{
    if (A == NULL) { cout << "ERROR\tNULL" << endl; system("pause"); exit(2); }
    else
    {
        if (N != z.N) { return 1; }
        else
            for (unsigned i = 0; i < N; ++i)
            {
                if (A[i] != z.A[i]) { return 1; }
            }
        return 0;
    }
}
 
template <class T>
ostream & operator <<(ostream &p, const Tvector<T>&z)
{
    if (z.A == NULL) { p << NULL; return p; }
    else
    {
        for (unsigned i = 0; i < z.N; ++i)
        {
            p << z.A[i] << '\t';
        }
        return p;
    }
}
 
template <class T>
istream & operator >> (istream &p, Tvector<T>&z)
{
    p >> z.N;
    if (z.N == 0) { cout << "ERROR\tNULL" << endl; system("pause"); exit(2); }
    delete[] z.A;
    z.A = new T[z.N];
    for (unsigned i = 0; i < z.N; ++i) { p >> z.A[i]; }
    return p;
}
 
class charvector : public Tvector<char>
{
public:
    charvector();
    charvector(int n);
    charvector(const charvector&);
    charvector(unsigned, const char &);
    ~charvector();
 
    charvector(char);
    charvector(const char* const);
 
    const charvector& operator+() const;
    const charvector operator-() const;
    const charvector operator+(const charvector&) const;
    const charvector operator-(const charvector&) const;
    const bool operator<=(const charvector&) const;
    const bool operator>=(const charvector&) const;
    const bool operator<(const charvector&) const;
    const bool operator>(const charvector&) const;
 
 
};
 
charvector::charvector(int n) { A = new char[n]; N = n; }
charvector::charvector() : Tvector<char>() {}
charvector::charvector(unsigned n, const char &a) : Tvector <char>(n, a) {}
charvector::charvector(const charvector&z) : Tvector<char >(z) {}
charvector::~charvector() {}
charvector::charvector(char a) : Tvector<char>(1, a) {}
charvector::charvector(const char* const p) : Tvector<char>()
{
    unsigned i = 0;
    while (p[i++]);
    A = new char[N = i - 1];
    if (A == NULL) { cout << "ERROR\tNULL" << endl; system("pause"); }
    for (i = 0; i < N; ++i) A[i] = p[i];
}
 
const charvector& charvector::operator+()const
{
    return *this;
}
const charvector charvector::operator-()const
{
    if (N == 0) return charvector();
    charvector p(N);
    for (int i = 0; i < N; ++i) p.A[i] = -A[i];
    return p;
}
 
 
const charvector charvector::operator+(const charvector &z) const
{
    charvector p(z.N + N);
    for (unsigned i = 0; i < N; ++i) p.A[i] = A[i];
    for (unsigned i = 0; i < z.N; ++i) p.A[N + i] = z.A[i];
    return p;
}
const charvector charvector::operator-(const charvector &z) const
{
    
}
 
const bool charvector::operator<=(const charvector &z)const
{
    unsigned i = 0;
    while (1)
    {
        if (i >= N && i < z.N) return true;
        else if (i < N && i >= z.N) return false;
        else if (i >= N && i >= z.N)return true;
        else if (A[i] <= z.A[i])return true;
        else if (A[i] > z.A[i])return false;
        else ++i;
    }
}
const bool charvector::operator>=(const charvector &z)const
{
    unsigned i = 0;
    while (1)
    {
        if (i <= N && i > z.N) return true;
        else if (i > N && i <= z.N) return false;
        else if (i <= N && i <= z.N)return true;
        else if (A[i] >= z.A[i])return true;
        else if (A[i] < z.A[i])return false;
        else ++i;
    }
}
const bool charvector::operator<(const charvector &z)const
{
    unsigned i = 0;
    while (1)
    {
        if (i >= N && i < z.N) return true;
        else if (i < N && i >= z.N) return false;
        else if (i >= N && i >= z.N)return false;
        else if (A[i] <= z.A[i])return true;
        else if (A[i] > z.A[i])return false;
        else ++i;
 
    }
}
const bool charvector::operator>(const charvector &z)const
{
    unsigned i = 0;
    while (1)
    {
        if (i >= N && i < z.N) return false;
        else if (i < N && i >= z.N) return true;
        else if (i >= N && i >= z.N)return true;
        else if (A[i] <= z.A[i])return false;
        else if (A[i] > z.A[i])return true;
        else ++i;
 
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_ALL, "RUSSIAN");
    charvector c("b"), b("f");
    charvector a("a"), k("5"), t("сон"), d("5");
 
 
    cout << b << a << k << endl;
    cout << t + b << endl;
    cout << d << c << b << endl;
    if (k < d) { cout << "true" << endl; }
    else { cout << "false" << endl; }
    if (b >= a ) { cout << "true" << endl; }
    else { cout << "false" << endl; }
    if (b <= a) { cout << "true" << endl; }
    else { cout << "false" << endl; }
    if (b > a) { cout << "true" << endl; }
    else { cout << "false" << endl; }
    if (b < a) { cout << "true" << endl; }
    else { cout << "false" << endl; }
 
 
 
    system("pause");
    return 0;
}