Ошибка при попытке создания шаблона

template<bool (*func1)(int), void (*func2)(int&), void (*func3)(int&, eDirection),
          void(*func4)(int&), int** tileMap>
static void threeFuncTrySet(int x, int y, eDirection d){
    if(func1(tileMap[x][y])){
        func2(tileMap[x][y]);
        func3(tileMap[x][y], d);
        func4(tileMap[x][y]);
    }
}
 
 
void aabb (int** tileMap){
 
void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<&Map::isGardenWithoutWallFlag, 
        &Map::setNothing, &Map::incrementRoad, &Map::setFlagWall, tileMap>;
 
}

#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        class Pointer2Pointer
    >
    static void threeFuncTrySet(int x, int y, eDirection d)
    {
        typedef typename ::std::remove_pointer<Pointer2Pointer>::type
            Pointer;
            
        static_assert( ::is_pointer<Pointer>::value, 
            "ERROR: invalid type Pointer2Pointer" );
            
        typedef typename ::std::remove_pointer<Pointer>::type
            Value;
            
        static_assert( !::is_pointer<Value>::value && ::std::is_object<Value>::value, 
            "ERROR: invalid type Pointer2Pointer" );
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap)
{
    
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**
    >;
    
    (void)treeFunc;
 
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T
    >
    static void threeFuncTrySet(int, int, eDirection)
    {
        static_assert( ::std::is_same<T, int**>::value, 
            "ERROR: parameter T must be int**");
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap)
{
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**
    >;
    (void)treeFunc;
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

template<bool (*func1)(int), void (*func2)(int&), void (*func3)(int&, eDirection), void(*func4)(int&)>
static void threeFuncTrySet(int x, int y, eDirection d, int** tileMap)

template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T
    >
class Obj{
   int** tileMap;
   Obj(int** t): tileMap(t){}
   void doThis(int x, int y, eDirection d){
      if(func1(tileMap[x][y])){
         func2(tileMap[x][y]);
         func3(tileMap[x][y], d);
         func3(tileMap[x][y]);
      }
   }
}

#include <iostream>
using namespace std;
 
enum eDirection { direction = 1 };
 
//----------------------------------------------------------------------------------------
 
 
int value = 10;
int* pvalue = &value;  //<--- статическая переменная. 
     //Является фундаментальным типом с++.  
    //Можно передать в параметре шаблона
 
struct Map
{
    template<
        bool (*func1)(int), 
        void (*func2)(int&), 
        void (*func3)(int&, eDirection),
        void(*func4)(int&),
        typename T, T obj
    >
    static void threeFuncTrySet(int, int, eDirection)
    {
        static_assert( ::std::is_same<T, int**>::value, 
            "ERROR: parameter T must be int**");
    }
    
    static bool isGardenWithoutWallFlag(int){ return false; }
    static void setNothing(int&){}
    static void incrementRoad(int&, eDirection){}
    static void setFlagWall(int&){}
};
 
//---------------------------------------------------------------------------------------- 
 
void aabb (int** tileMap) //<--- аргумент функции нельзя использовать в параметрах шаблона
{                                
    void (*treeFunc)(int, int, eDirection) = &Map::threeFuncTrySet<
        &Map::isGardenWithoutWallFlag, 
        &Map::setNothing, 
        &Map::incrementRoad, 
        &Map::setFlagWall,
        int**, 
        &pvalue  //<--- статическая переменная. Можно.
    >;
    (void)treeFunc;
}
 
//---------------------------------------------------------------------------------------- 
 
int main()
{
    std::cout << "Hello, world!\n";
}

#include <iostream>
 
struct example
{
    static void gen(){}
    
    enum { id = &gen };
};
 
int main()
{
    std::cout << "Hello, world!\n";
}

/*extern*/ int f1() // внешнее связывание
{
}
 
static int f2() // внутренее связывание
{
}
 
template <int (*v)()>
struct B
{
};
 
int main()
{
    B<&f1> c1; // OK
    B<&f2> c2; // ERROR
}

#include <iostream>
 
constexpr size_t foo() { return (size_t)&foo; }
 
struct example
{
    enum { it = foo() };
};
 
int main()
{
    std::cout << "Hello, world!\n";
}

enum { it = foo() };

typedef int (*func_t)();
 
template <func_t a, func_t b>
struct C
{
    static constexpr func_t f_arr[] = { a, b };
};

template<class T, bool is_int = ::std::is_same<int, T>::value >
struct example
{
};

bool is_int = ::std::is_same<int, T>::value

bool is = true

void (*ptr)() = foo;

static constexpr func_t f_arr[] = { a, b };

typedef int ( *func_t)();
 
template <func_t a, func_t b, bool f>
struct C
{
    static constexpr func_t f = a;
};
 
template <func_t a, func_t b>
struct C<a, b, true>
{
    static constexpr func_t f = b;
};
 
template <typename T, func_t a, func_t v = C<a, &f2, std::is_integral<T>::value>::f>
struct B
{
};
 
int main()
{
    typedef B<int, f1> test_t;
}