Шаблоны функции и указатель на функцию передаваемый в функцию

template<typename T>
bool ascending(T a, T b)
{
    return a < b;
}
 
template<typename T>
bool descending(T a, T b)
{
    return a > b;
}
 
template<typename T>
void bubbleSort(T* a, const int size, bool(*compare)(T, T))
{
    for(int i = 0; i < size - 1; i++)
    {
        int index = i;
        for(int j = i + 1; j < size; j++)
        {
            if(compare(a[index], a[j])
            {
                index = j;
            }
        }
        T temp = a[i];
        a[i] = a[index];
        a[index] = temp;
    }
}

template<typename elementType1, int numberOfElements1>
        Test<elementType, numberOfElements>& operator=(const Test<elementType1, numberOfElements1>& right)
        {
            if(numberOfElements != numberOfElements1)
            {
                            //size = right.size;
                            //delete[] array;
                array[numberOfElements1];
            }
            for(int i = 0; i < numberOfElements1; i++)
                array[i] = right.array[i];
            return *this;
        }

#ifndef TEST_H
#define TEST_H
 
#include <iostream>
using std::ostream;
using std::istream;
 
template<typename elementType, int numberOfElements>
class Test
{
    friend ostream& operator<<(ostream&, const Test<elementType, numberOfElements>&);
    friend istream& operator>>(istream&, Test<elementType, numberOfElements>&);
    public:
        Test();
        //Test(int);
        //Test(int, int); //конструктор получет два параметра первый размер массива, второй чем запонить массив
        Test(const Test&);
        ~Test();
 
        /*Test& operator=(const Test& right)
        {
            if(this != &right)
            {
                if(size != right.size)
                {
                    size = right.size;
                    array[size];
                }
                for(int i = 0; i < size; i++)
                    array[i] = right.array[i];
            }
            return *this;
        }*/
        
        template<typename elementType1, int numberOfElements1>
        Test<elementType, numberOfElements>& operator=(const Test<elementType1, numberOfElements1>& right)
        {
            if(numberOfElements != numberOfElements1)
            {
                Test<elementType1, numberOfElements1>();
            }
            for(int i = 0; i < numberOfElements1; i++)
                array[i] = right.array[i];
            return *this;
        }
        
 
        bool operator==(const Test&) const;
        bool operator!=(const Test& right) const
        {
            return !(*this == right);
        }
        
        elementType& operator[](int);
        elementType operator[](int) const;
 
        int getSize() const;
    private:
        int size;
        elementType* sPtr;
        elementType newArray;
        elementType array[numberOfElements];
};
 
#include <iostream>
using std::cout;
using std::endl;
using std::cerr;
 
#include <iomanip>
using std::setw;
 
template<typename elementType, int numberOfElements>
Test<elementType, numberOfElements>::Test():size(numberOfElements)
{
    for(int i = 0; i < size; i++)
        array[i] = 0;
 
}
 
template<typename elementType, int numberOfElements>
Test<elementType, numberOfElements>::Test(int s):size((s > 0) ? s : 10)
{
    sPtr = new elementType[size];
    for(int i = 0; i < size; i++)
        sPtr[i] = 0;
}
 
template<typename elementType, int numberOfElements>
Test<elementType, numberOfElements>::Test(int s, int simbol):size((s > 0) ? s : 10)
{
    sPtr = new elementType[size];
    for(int i = 0; i < size; i++)
        sPtr[i] = simbol;
}
 
 
template<typename elementType, int numberOfElements>
Test<elementType, numberOfElements>::Test(const Test<elementType, numberOfElements>& arr):size(arr.numberOfElements)
{
    //sPtr = new typeElement[size];
    newArray[size];
 
    for(int i = 0; i < size; i++)
        newArray[i] = arr.array[i];
}
 
template<typename elementType, int numberOfElements>
Test<elementType, numberOfElements>::~Test()
{
    delete[] sPtr;
    //delete[] array;
}
 
 
template<typename elementType, int numberOfElements>
bool Test<elementType, numberOfElements>::operator==(const Test<elementType, numberOfElements>& right) const
{
    if(size != right.size)
        return false;
    for(int i = 0; i < size; i++)
        if(sPtr[i] != right.sPtr[i])
            return false;
    return true;
}
 
 
 
template<typename elementType, int numberOfElements>
elementType& Test<elementType, numberOfElements>::operator[](int index)
{
    if(index < 0 || index >= size)
    {
        cerr << "\nErroe subscript " << index << " out of range" << endl;
        system("Pause");
        exit(1); //завершить программу,т.к. индекс вне диапазона
    }
    
    return array[index];
}
 
template<typename elementType, int numberOfElements>
elementType Test<elementType, numberOfElements>::operator[](int index) const
{
    if(index < 0 || index >= size)
    {
        cerr << "\nErroe subscript " << index << " out of range" << endl;
        system("Pause");
        exit(1); //завершить программу,т.к. индекс вне диапазона
    }
    
    return array[index];
}
 
 
template<typename elementType, int numberOfElements>
int Test<elementType, numberOfElements>::getSize() const 
{
    return size;
}
 
template<typename elementType, int numberOfElements>
ostream& operator<<(ostream& os, const Test<elementType, numberOfElements>& right)
{
    int i;
    for(i = 0; i < right.size; i++)
    {
        if((i + 1) % 15 == 0)
            os << endl;
        os << setw(5) << right.array[i]; 
    }
    if(i % 15 == 0)
        os << endl;
 
    return os;
}
 
template<typename elementType, int numberOfElements>
istream& operator>>(istream& input, Test<elementType, numberOfElements>& right)
{
    input >> setw(right.size) >> right;
    return input;
}
#endif

template<typename A, typename B>
A& assign_whatsoever(A& a, B&b){
return a+=b;
}
int main(int argc, char* argv[])
{
float a=3;
int b=4;
a=assign_whatsoever(a,b);
cout<<a<<endl;//7 компилятор видит преобразование int -> float 
char* c="mama daragaya";
//а тут не получается
//a=assign_whatsoever(a,c);//: error C2440: +=: невозможно преобразовать 'char *' в 'float'
cout<<endl;
system("pause");
return 0;
}

#include <iostream>
using namespace std;
 
template< typename T>
void show_container(T it_start, T it_end ){
while(it_start != it_end) cout << *it_start++ ;
cout<<endl;
}
 
 
const size_t n=10;
int a[n];
template <size_t N, typename T, T(&array_T)[N]>
struct Array_T{
    Array_T(){for(size_t i=0; i<N; ++i)array_T[i]=0;}
     T* get_iter(size_t i){ return &array_T[i];  }
 
};
 
//но вышепоказанный тип нуждается в глобальном массиве в качестве параметра
//ещё хуже то что любой инстанс укажет на этот же массив (см. код)
//или
template<typename T, size_t length>
struct Arra{
//константа length позволяет создавать массив не выделяя память вручную:
T arra[length];//а тут это всегда свой массив
Arra(){
for(size_t i=0; i<length; ++i)arra[i]=0;
}
size_t get_length(){return length;}
 
Arra& operator == (const Arra& rhs){
    if(this!=&rhs && length == rhs.get_length()){
for(size_t i=0; i<length; ++i)arra[i]=rhs.arra[i];
    }
    return *this;
}
};
 
int main(int argc, char* argv[])
{
Array_T<n, int, a> arr_T1;
show_container(arr_T1.get_iter(0), arr_T1.get_iter(n));
Array_T<n, int, a> arr_T2;
*arr_T2.get_iter(0)=123;
cout<<*arr_T1.get_iter(0)<<endl;
 
Arra<int, 5> arra1;
show_container(&(arra1.arra[0]) , &(arra1.arra[0])+arra1.get_length());
Arra<int, 5> arra2;
arra2.arra[1]=123;
show_container(&(arra2.arra[0]) , &(arra2.arra[0])+arra2.get_length());
show_container(&(arra1.arra[0]) , &(arra1.arra[0])+arra1.get_length());
 
arra1=arra2;
show_container(&(arra1.arra[0]) , &(arra1.arra[0])+arra1.get_length());
cout<<endl;
system("pause");
return 0;
}

template<typename T, int length>
имя class<T, length>&  область действия_class<T, length>::имя_функции(const имя типа<T, length>&)

template<typename elementType = float> class Test{};

template<size_t length>
struct Arra<float, length>{
//константа length позволяет создавать массив не выделяя память вручную:
float arra[length];//а тут это всегда свой массив
Arra(){
for(size_t i=0; i<length; ++i)arra[i]=0;
}
 
// расширение функциональности (хотя это, как раз, можно бы обобщить и для типа-параметра Т)
Arra( float *fl ){
for(size_t i=0; i<length; ++i)arra[i]=fl[i];
}
 
size_t get_length(){return length;}
 
Arra& operator == (const Arra& rhs){
    if(this!=&rhs && length == rhs.get_length()){
for(size_t i=0; i<length; ++i)arra[i]=rhs.arra[i];
    }
    return *this;
}
//эта функция чревата переполнением по результату и нужна лишь для
//демонстрации расширения функциональности
int get_all_integer_part(){
int sum(0);
for(size_t i=0; i<length; ++i)sum+=static_cast<int>(arra[i]);
return sum;
}
};
 
int main(int argc, char* argv[])
{
float af[]={1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
Arra<float,5> af_af(af);
cout<<af_af.get_all_integer_part()<<endl;
system("pause");
return 0;
}