Ich habe folgenden Fehler beim Ausführen des Quellcodes:

main.cpp

#include <iostream>
#include "min.h"

using namespace std;

int main(void)
{	
	int min=0;
	int bla[]={5,3,-2,1,8,10,-5,4,7,-14,6,-3,123,56,-46};
	min=MyMin(bla,15);
	cout << "Kleinstes Element ist "<< bla[min]<< " an Position " <<min<<endl;

	float blub[]={1.0,4.6,3.5,4.3,-9.6,10.0,-3.4,1.0,-2,9};
	min=MyMin(blub,8);
	cout << "Kleinstes Element ist "<< blub[min]<< " an Position " <<min<<endl;

	char *scheissendreck[]={"schei","sse","en","dreck!"};
	min=MyMin(scheissendreck,4);
	//cout << "Kleinstes Element ist "<< blub[min]<< " an Position " <<min<<endl;

	return 0;
}

min.h

#ifndef BLA
#define BLA

#include <string>

template <class T>
int MyMin(const T* feld ,int const anz)
{
	int min=0;
	for(int i=0; i<anz; i++ )
	{
		if(feld[i]<feld[min])
			min=i;	
	}

	return min;
}
template <>
int MyMin(char** feld, const int anz)
{
	int min=0;
	for(int i=0; i<anz;i++)
	{
		if(strlen(feld[i])<strlen(feld[min]))
		min=i;
	}
	return min;
}

#endif

Mit den Zahlen funktionert es reibungslos, bloß bei dem Char Arrays muckt es rum und es kommt folgende Fehlermeldung:
**error C2912: Explizite Spezialisierung; 'int MyMin(char ,const int)' ist keine Spezialisierung einer Funktionsvorlage

kann mir jemand sagen, wo mein Fehler liegt?

int MyMin(char* const* feld, const int anz)

?

template <tpyename range_type>
range_type& min_range(const range_type* data, std::size_t size)
{
    assert(size > 0);
    range_type& min(data[0]);
    while (size > 0) 
        if (min > data[--size])
            min = data[size];

    return min;
}

template <class T>
int MyMin(const T feld ,int const anz)
{
    int min=0;
    for(int i=0; i<anz; i++ )
    {
        if(feld[i]<feld[min])
            min=i;   
    }

    return min;
}

@DeSoVoDaMu:

ich kapier nicht warum das funktioniert!
ist ja komisch!

char *scheissendreck[]={"schei","sse","en","dreck!"};

Das ist ein char Zeiger-array von char zeiger.

int MyMin(char** feld, int const anz)

Also müsste es ja hier auch zeiger auf zeiger sein um dann mit "feld" auf die elemente zuzugreifen!

int MyMin(char* const* feld, int const anz)

Was bedeutet das? einen zeiger auf einen konstanten char?

kapier ich nicht! könntest du das weiter erläutern?

int MyMin(char *const *feld, int const anz)

das ist ein konstanter char-zeiger auf einen char-zeiger!

aber nun 2 fragen:

1. wieso muss der erste zeiger konstant sein?
2. wieso wird bei

int MyMin(const char *const *feld, int const anz)

Position 3 ausgegeben?

Ich soll aus einem Array, das aus Zahlen besteht, das Minimum bestimmen und die Position bestimmen!

Also habe ich zu erst die erste MyMin Funktionen geschrieben und mit den beiden verschiedenen (float, int) Arrays getestet - hat auch astrein funktioniert.

Nun sollte man noch eine spezifische Funktion implementieren, das aus einem char Array die Position der kürzesten Zeichenkette bestimmt.

Also habe ich die spezifische template Funktion mit "template<>" eingeleitet! Aber leider hat das mit meiner Methode nicht funktioniert.

Deshalb habe ich die Frage hier gestellt.

Also meine Fragen bestehen immernoch

template <>
int MyMin(char** feld, const int anz)

ich kapier nicht warum das funktioniert!

Ich habe mir einfach die template-Deklaration angeschaut.

int MyMin(const T* feld ,int const anz)

Das ist quasi ein Zeiger auf ein konstantes T.

Setz ich jetzt fuer T char* ein erhalte ich einen Zeiger auf einen konstanten char-Zeiger ->

char* const*

Das fehlende const ist das, was dir der Compiler sagen will, weil dann eben die Spezialisierung nicht mehr zur der Vorlage passt.

Edit:
PS: wenn dir die Zeigersyntax und deren Bedeutung nicht ganz klar ist, schau vielleicht mal hier rein

ich weiß, dass er bei der ersten funktion nur die zeiger vergleichen würde, deshalb habe ich ja die zweite funktion (unter template<>)

ah verdammt, ich habe using namespace std vergessen, ich depp! nochmal testen!

hmm..geht auch nicht

was funktioniert nicht?

#include <iostream>
using namespace std;

template <class T>
int MyMin(const T feld ,int const anz)
{
    int min=0;
    for(int i=0; i<anz; i++ )
    {
        if(feld[i]<feld[min])
            min=i;   
    }

    return min;
}

template<>
int MyMin(char **const  feld, const int anz)
{
    int min=0;
    for(int i=0; i<anz;i++)
    {
        if(strlen(feld[i])<strlen(feld[min]))
        min=i;
    }
    return min;
} 

int main(void)
{   
    int min=0;
    int bla[]={5,3,-2,1,8,10,-5,4,7,-14,6,-3,123,56,-46};
    min=MyMin(bla,15);
    cout << "Kleinstes Element ist "<< bla[min]<< " an Position " <<min<<endl;

    float blub[]={1.0,4.6,3.5,4.3,-9.6,10.0,-3.4,1.0,-2,9};
    min=MyMin(blub,8);
    cout << "Kleinstes Element ist "<< blub[min]<< " an Position " <<min<<endl;

    char *scheissendreck[]={"schei","sse","en","dreck!", "pn", "d", "az"};
    min=MyMin(scheissendreck,7);
   cout << "Kleinstes Element ist "<< scheissendreck[min]<< " an Position " <<min<<endl;

    return 0;
}