Массив указателей на функцию в классе

#include <stdlib.h>
#include "iostream"
 
using namespace std;
 
template <class T> //Шаблон Pr класса с параметром T
class Pr
{
 T x;
bool A_1(T x, int n) {return x < n;}//Меньше 1
bool A_1_1(T x, int n) {return ((x <n)&&(x != 0))||((x>n)&&(x != 0));}//Не 0 и не 1
bool A_0_1(T x, int n = 0){return x >=n;}//Больше или =1
bool A_0(T x, int n){return (x == 0)&&(n ==0);}//Если 0
bool A_n(T x, int n){return x > n;}//Больше числа
bool A_2(int x, int n){return x % n != 0;}//Проверка на целое
typedef void (*P)();//указатель на функцию
void Serror( const int);//Функция вывода строк (массив указателей)
public:Pr()
 {
    memset(Pf,A_1,A_1_1,A_0_1,A_0,A_n,A_2 , sizeof(Pf));
 }
 P Pf [];//объявим массив из указателей на функцию
 T Oshibka (T x, const int n,P Pf[], const int M, const int N)//Функция принимает указатели на функции
{
    x =GetChislo ();
    while ( Pf [M]){Serror(N);x = GetChislo();}
 
return x;
}
T GetChislo ()           //Функция ввода
{
    while (!(cin >> x) || cin.peek() != '\n')
    {
        cin.clear();
        while (cin.get() != '\n');Serror(6);
    }
 return x;
}
};
int main()
{
 system("chcp 1251 > nul");
 int c = 0;
 Pr<int> S;
 cout<<"Введите число "<<"\n";
 c = S.GetChislo ();
 //c = S.Oshibka(c,5,4,0);//Здесь ошибка.
 cout <<"    "<<c<<"\n";
return 0;
}
template <class T>
void Pr <T>::Serror(const int n)
{
const char *Ar[]=
 {
" Число может быть 0 или 1                                  \n",
" Число может быть 1, 2, 3                                  \n",
" Число не может быть не четным и больше 24                 \n",
" Число не может быть   0                                   \n",
" Число не может быть меньше 1                              \n",
" Число  не может быть больше 6                             \n",
" Введен недопустимый символ.Вводить можно числа и точку    \n",
"    ОШИБКА!!!!           ОШИБКА!!!!                        \n"
"        ПОВТОРИТЕ ВВОД!                                    \n"
};
cout << Ar[7];
cout << Ar[n];
}

#include <iostream>
#include <clocale>
 
class Nothing
{
  public:
    Nothing() { setlocale(LC_ALL, ""); }
    virtual void print() const = 0;
    void doNothing() const {}
    virtual ~Nothing() {}
};
 
void Nothing::print() const
{
    std::cout << "It's nothing to do" << std::endl;
}
 
class Something : private Nothing
{
  public:
    void print() const
    {
        doNothing();
        std::cout << "С - Сережа и Петя (известно по условию)\n"
                 "Паскаль - Коля, Петя и Сережа (известно по условию)\n"
                 "Бэйсик - Коля\n";
    }
    virtual ~Something() {}
};
 
class Just4Fun : public Something
{
  public:
    Just4Fun() : smth(new Something)
    {
        pfS memf_ptr = &Just4Fun::print;
        (smth->*memf_ptr)();
    }
    ~Just4Fun()
    {
        delete smth;
    }
 
  private:
    typedef void (Something::*pfS)() const;
    Something* smth;
};
 
 
int main()
{
    Just4Fun makeItReal;
}

#include <iostream>
#include <clocale>
 
// базовый абстрактный класс
class Nothing
{
  public:
    Nothing() { setlocale(LC_ALL, ""); } // конструктор по-умолчанию
    virtual void print() const = 0;      // чисто виртуальная функция
    void doNothing() const {}            // обычная виртуальная функция
    virtual ~Nothing() {}                // виртуальный деструктор т.к.
                                         // предполагается наследование
};
 
// реализация чисто-виртуальной функции
// тут некоторые скажут оО , но оно таки существует
void Nothing::print() const
{
    std::cout << "It's nothing to do" << std::endl;
}
 
// класс-наследник от Nothing (Something является производным классом от Nothing)
// используется приватное наследование, что означает, что Something реализуется
// посредством Nothing.
// тут можно загнаться на тему философии, важно лишь помнить, что все поля
// (в т.ч. конструктор) базового класса будут иметь модфиикатор доступа private
class Something : private Nothing
{
  public:
    void print() const // определение чисто-виртуальной функции, класс более не 
    {                  // абстрактный
        doNothing();   // вызываем приватный метод просто чтобы показать, что мы
                       // так умеем
        std::cout << "С - Сережа и Петя (известно по условию)\n"
                 "Паскаль - Коля, Петя и Сережа (известно по условию)\n"
                 "Бэйсик - Коля\n"; // выводим очевидный ответ на неизвестную задачу
    }
    virtual ~Something() {}         // т.к. предполагается наследование от данного
                                    // класса, то делаем конструктор виртуальным
};
 
// наследование означает, что Just4Fun является Something. Я бы сказал, что он
// является что-то с чем-то. Модификаторы доступа для наследуемых членов
// базового класса не изменяются
class Just4Fun : public Something
{
  public:
    Just4Fun() : smth(new Something)     // инициализируем указатель на базовый 
    {                                    // класс новым динам. объектом Something
        pfS memf_ptr = &Just4Fun::print; // объявляем указатель типа pfS на метод
                                         // класса, который наследуется от Something
                                         // (т.к. благодаря тому, что функция print()
                                         // виртуальна в базовом классе, то
                                         // наследуется её интерфейс и реализация
                                         // по-умолчанию)
        (smth->*memf_ptr)();             // вызываем метод, на который указывает
                                         // наш новый указатель, передавая ему
                                         // в качестве аргументов void в круглых
                                         // скобках
    }
    ~Just4Fun()
    {
        delete smth;                     // освобождаем память под динамический
                                         // объект типа Something
    }
 
  private:
    typedef void (Something::*pfS)() const; // объявляем синоним на указатель на
                                            // константный метод Something,
                                            // возвращающий тип void
                                            // и не принимающий никаких аргументов
    Something* smth;                        // указатель на базовый класс
};
 
 
int main()
{
    // делаем это реальным
    Just4Fun makeItReal; // Говорят, тут происходит особая темная магия ]:>
}