Шаблон, специализация: поиск самой большой строки в массиве указателей на char

#include <cstdlib>
#include <iostream>
template <typename T>//shablon
void maxn(T arr[],int cz);
template <> void maxn(char * cArr,int p);//spezializacia
using namespace std;
int main(int argc, char *argv[])
{
    int mass1[6] = {5,90,3,2,9,7};
    maxn(mass1,6);
    double mass2[4] = {4.8,8.0,5.3,3.14};
    maxn(mass2,4);
    cout<<"rabotaet cArr[5]!"<<endl;
    char * mchar[5] = {
                       "Dasha",
                       "Inokenty",
                       "Jora",
                       "Tanyasdw",
                       "Irina"
                      };
                             
    maxn(mchar,5);//ПРОБЛЕМА С ЭТОЙ ФУНКЦИЕЙ=)
    system("PAUSE");
    return EXIT_SUCCESS;
}
template <typename T>
void maxn(T arr[],int cz)
{ 
    double maxx = arr[0];
    for(int i = 1;i<cz;i++)
    {
        if(arr[i] > maxx)
         maxx = arr[i];
    }
    cout<<"bolshee chislo:"<<maxx<<endl;
}
template <> void maxn(char * cArr,int p)
{
   char(*db)[] = cArr[0][0];
  for(int i=0;i<p;i++)
   {
     if(cArr>db)
      db = cArr; 
    }     
    cout<<"adress stroki:"<<db<<endl;
    // for(int i = 0;i<p;++i)
    //cout<<maxx[i]<<"  adress:"<<&maxx[i]<<endl; 
}

#include <iostream>
//#include <list>
 
template<typename T>
T func(T arr[], int S){
    //....
    return arr[0];
}
 
template<>
const char *func(const char *arr[], int S){
    const char *buff = arr[0];
    for(int i = 1; i < S; ++i){
        if(strlen(buff) < strlen(arr[i]))
            buff = arr[i];
    }
 
    return buff;
}
int main(){
 
    int arr[3] = {1, 2, 3};
 
    const char *sarr[3] = {
        "asd",
        "asdf",
        "asd"
    };
 
    std::cout << func(sarr, 3) << std::endl; // asdf
 
    std::cout << func( arr, 3) << std::endl; // 1 
    return 0;
}

#include <cstdlib>
#include <iostream>
template <typename T>//shablon
void maxn(T arr[],int cz);
template <>
const char * maxn(const char * cArr[],int p);//spezializacia
using namespace std;
int main(int argc, char *argv[])
{
    int mass1[6] = {5,90,3,2,9,7};
    maxn(mass1,6);
    double mass2[4] = {4.8,8.0,5.3,3.14};
    maxn(mass2,4);
    cout<<"rabotaet cArr[5]!"<<endl;
    const char * mchar[9] = {
                       "Dasha",
                       "InokentyW",
                       "Jora",
                       "Tanyasdw",
                       "IrinaW"
                      };
                             
    cout<<maxn(mchar,5);
    system("PAUSE");
    return EXIT_SUCCESS;
}
///
template <typename T>
void maxn(T arr[],int cz)
{ 
    double maxx = arr[0];
    for(int i = 1;i<cz;i++)
    {
        if(arr[i] > maxx)
         maxx = arr[i];
    }
    cout<<"bolshee chislo:"<<maxx<<endl;
}
///
template <> const char * maxn(const char * cArr,int p)
{  
     char *buff = cArr;
        for(int i = 1; i < p; ++i)
          {
            if(strlen(buff) < strlen(cArr[i]))
            buff = cArr[i];   
          }   
    return buff;
}

#include <cstdlib>
#include <iostream>
 
///
template <typename T>
T func_max(T arr[], int count)
{ 
    T Res = arr[0];
    for(int i = 0; i < count; ++i)
        if(arr[i] > Res)
            Res = arr[i];
    return Res;
}
 
template <> 
const char *func_max(const char *cArr[], int count)
{  
    const char *Res = cArr[0];
    for(int i = 0; i < count; ++i)
        if(strlen(Res) < strlen(cArr[i]))
            Res = cArr[i];    
    return Res;
}
 
int main(int argc, char *argv[])
{
    int     mass1[6] = { 5, 90, 3, 2, 9, 7  };
    double  mass2[4] = { 4.8, 8.0, 5.3, 3.14};
    const char *mchar[5] = 
    {
        "Dasha",
        "InokentyW",
        "Jora",
        "Tanyasdw",
        "IrinaW"
    };
 
    std::cout << func_max(mass1,6) << std::endl;
    std::cout << func_max(mass2,4) << std::endl;
    std::cout << func_max(mchar,5) << std::endl;
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <iostream>
using namespace std;
 
template<typename T> class IsFundamental{
public:
    enum { Yes = 0, No = 1 };
};
 
template<> class IsFundamental<int>{
public:
    enum { Yes = 1, No = 0 };
};
 
#define MK_FUND_TYPE(T)             \
template<> class IsFundamental<T>{  \
public:                             \
    enum { Yes = 1, No = 0 };       \
}
 
MK_FUND_TYPE(double);
MK_FUND_TYPE(float);
MK_FUND_TYPE(char);
MK_FUND_TYPE(void);
MK_FUND_TYPE(bool);
//MK_FUND_TYPE(int);
//...........
 
 
class MyType{};
 
int main()
{
 
    if(IsFundamental<int>::Yes)
        std::cout << "Ok..\n";
 
    if(IsFundamental<float>::Yes)
        std::cout << "Ok..\n";
 
    if(IsFundamental<int*>::Yes)
        std::cout << "((((..\n";
 
    if(IsFundamental<MyType>::Yes)
        std::cout << "((((..\n";
 
    return 0;
}