3. template funktion kann nicht richtig gefunden werden

template funktion kann nicht richtig gefunden werden

  • P

    ich habe die Funktionen

    template<typename T>
int ArraysFunctions::ArrayCenterPos(vector<T> & InArray, T threshold)
{
	return ArraysFunctions::ArrayCenterPos(&InArray[0], (int)InArray.size(), threshold);
}

template<typename T>
int ArraysFunctions::ArrayCenterPos(complex<T>* InArray, int size, T threshold)
{
...
}

template<typename T>
int ArraysFunctions::ArrayCenterPos(T * InArray, int size, T threshold)
{
...
}

    die allerdings bei einem Aufruf mit T = vector<complex<double>> den Fehler auswirft:

    1>.\src\LaserData.cpp(349) : error C2780: 'int ArraysFunctions::ArrayCenterPos(T *,int,T)' : expects 3 arguments - 2 provided
    1> h:\Dev\CPP\SVN\modelocksimulation\ModelockingSimulation2\include\matthias\Common\ExtFunctions.h(47) : see declaration of 'ArraysFunctions::ArrayCenterPos'
    1>.\src\LaserData.cpp(349) : error C2782: 'int ArraysFunctions::ArrayCenterPos(std::vector<T> &,T)' : template parameter 'T' is ambiguous
    1> h:\Dev\CPP\SVN\modelocksimulation\ModelockingSimulation2\include\matthias\Common\ExtFunctions.h(46) : see declaration of 'ArraysFunctions::ArrayCenterPos'
    1> could be 'double'
    1> or 'std::complex<double>'

    an der Stelle

    vector<complex<double> > timeArray;
...
int maxpos = ArrayCenterPos(timeArray, 250.0);

    wie bringe ich den Compiler dazu die richtige Funktion zu wählen?

    0
  • Administrator

    In dem du dem Kompiler auch eine Funktion gibst, die er auswählen kann. Du willst wohl, dass er diese Funktion aufruft, oder?

    int ArraysFunctions::ArrayCenterPos(vector<T> & InArray, T threshold)

    Mal schauen was du übergibst:

    1. Argument Typ: vector<complex<double> >
2. Argument Typ: double

    Daraus folgt, dass der Template Parameter T zwei Typen ist? Nämlich entweder double oder complex<double> . Das kann ja nicht gehen!

    Grüssli

    0
  • P

    Stimmt, das habe ich jetzt hoffentlich durch ein

    template<typename T>
int ArraysFunctions::ArrayCenterPos(vector<complex<T>> InArray, T threshold)
{
	return ArraysFunctions::ArrayCenterPos(&InArray[0], (int)InArray.size(), threshold);
}

    gelöst.

    Aber ich habe zusätzlich das Problem das in einem solchen Fall nicht die richtige Funktion in der Funktion aufgerufen wird.

    Hier beim Kompilieren am Beispiel der Funktion

    template<typename T>
int ArraysFunctions::ArrayMaxPos(vector<T> const & InArray)
{	
	return ArraysFunctions::ArrayMaxPos(&InArray[0], (int)InArray.size());
}

template<typename T>
int ArraysFunctions::ArrayMaxPos(complex<T>* InArray, int size)
{	
...
}

template<typename T>
int ArraysFunctions::ArrayMaxPos(T * InArray, int size)
{	
...
}

    Wenn die oberste Funktion aufgerufen wird mit T = complex<double>, dann muss die Funktion mit complex<T> aufgerufen werden nicht die mit T.

    Das macht der Kompiler aber nicht:

    1>h:\Dev\CPP\SVN\modelocksimulation\ModelockingSimulation2\include\matthias\Common\ExtFunctions.h(337) : error C2678: binary '=' : no operator found which takes a left-hand operand of type 'const std::complex<double>' (or there is no acceptable conversion)
    1> C:\Programme\Microsoft Visual Studio 8\VC\include\complex(744): could be 'std::complex<double>::_Myt &std::complex<double>::operator =<double>(const std::complex<double> &)'
    1> C:\Programme\Microsoft Visual Studio 8\VC\include\complex(679): or 'std::complex<double> &std::complex<double>::operator =(const std::complex<double>::_Ty &)'
    1> C:\Programme\Microsoft Visual Studio 8\VC\include\complex(712): or 'std::complex<double>::_Myt &std::complex<double>::operator =(const std::complex<double>::_Myt &)'
    1> while trying to match the argument list '(const std::complex<double>, const std::complex<double>)'
    1> h:\Dev\CPP\SVN\modelocksimulation\ModelockingSimulation2\include\matthias\Common\ExtFunctions.h(308) : see reference to function template instantiation 'int ArraysFunctions::ArrayMaxPos<const std::complex<double>>(T *,int)' being compiled
    1> with
    1> [
    1> T=const std::complex<double>
    1> ]
    1> .\src\LaserDisturb.cpp(72) : see reference to function template instantiation 'int ArraysFunctions::ArrayMaxPos<std::complex<double>>(const std::vector<_Ty> &)' being compiled
    1> with
    1> [
    1> _Ty=std::complex<double>
    1> ]

    hier wird das letzte Funktionstemplate mit T=complex<double> genutzt, was aber nicht funktioneren kann. Daher die ersten paar operator Fehlermeldungen.

    0
  • Administrator

    Grundsätzlich ist es wieder das gleiche Problem, du gibst dem Kompiler nicht die richtigen Möglichkeiten.
    &InArray[0] gibt ein std::complex<double> const* zurück. Die Funktion, welche du aufrufen möchtest, erwartet aber ein std::complex<double>* . Also ein Zeiger auf ein nicht konstantes Objekt. Daher passt die Funktion ganz sicher nicht. Von der Signatur würde aber die letzte Funktion passen mit T als std::complex<double> const* . Du gibst dem Kompiler also schon wieder keine passende Funktion. Allerdings sollten die doch sowieso alle konstant sein?

    Allerdings frage ich mich auch ein wenig was du da eigentlich machen willst.
    Zum einen: Wieso willst du die Fälle unterscheiden?
    Zum anderen: Wieso verwendest du nicht das Iteratorenkonzept?
    Zum letzten: Wieso verwendest du nicht die Standardbibliothek für Algorithmen?

    Zum Beispiel:
    http://www.cplusplus.com/reference/algorithm/max_element/
    Gibt dir die Position, bzw. den Iterator, vom maximalsten Element.

    Grüssli

    0
Anmelden zum Antworten