C ++ Vorlagen Überlastauflösung schlägt fehl, wenn die Standardauflösung nicht wäre ⇐ C++

[Anonymous]

Es scheint eine Diskrepanz darüber zu bestehen, wie die Überladungen der Funktionsfunktionen aufgelöst werden und wie nicht getemktete Funktionen überlastet werden, aber es scheinen einige Fälle zu geben, in denen es keinen Unterschied machen sollte, aber es tut dies. Ich würde gerne wissen, ob es einen Grund gibt, warum dies der Fall ist. Angenommen, es ist nur einer für die Demonstration), der andere hat einen Parameter für einen Zeiger für Funktionstyp, der der Signatur des anderen über einen Vorlagen-Catch-All für die übrigen Funktionsparameter nach dem Vorlagenklassenobjekt entspricht. Ich kompiliere auch unter Windows, aber das sollte für dieses Problem keinen Unterschied machen.

Code: Select all

#include 

template < class _Ty >
class some_class
{
public:
some_class() = default;

void with_int( int value )
{
// Do something
}
};

// Used for a storage, of the function without the `std::function` class
template < class _Ty, class... _Args >
struct stored_function
{
void operator () ( _Args... args )
{ function( obj, args... ); }

some_class< _Ty >& obj;
void ( * function )( some_class< _Ty >&, _Args... );
};

// Use of `stored_function` struct
template < class _Ty, class... _Args >
stored_function< _Ty, _Args... > store( some_class< _Ty >& obj, void ( * function )( some_class< _Ty >&, _Args... ) )
{ return stored_function< _Ty, _Args... >{ obj, function }; }

// Template function for all class types `_Ty`.
template < class _Ty >
void some_function( some_class< _Ty >& obj, int my_int )
{ obj.with_int( my_int ); }

int main()
{
// The class
some_class< char > my_class;

// Storing the function
auto function_storage = store( my_class, some_function ); // ERROR: no matches converting function 'some_function' to type 'void (*)(class some_class&)'

// Using the stored function.
function_storage( 3 );
}

Das gewünschte Ergebnis wäre für die Funktion das erste Vorlagenargument _ty vom Typ char sein, da wir ein Objekt vom Typ SOCKASS bestehen. Da wir dann den ersten Typ abgeleitet haben, muss der Zeiger-zu-Funktion-Typ für den zweiten Parameter des Speichers ein slow_class einnehmen, da es das erste Argument ist, das wir dann in der Lage sein sollten, die spezifische Vorlagenüberlastung der Funktion zu verwenden, um zu sein. Daraus sollten wir dann in der Lage sein zu sehen, was den Platz von _args ... im Vorlageparameter einnehmen muss (in diesem Fall {int} ). Dies geschieht nicht, stattdessen können wir den Compiler nicht übergeben, da er den Typ des Funktionsarts nicht auflösen kann und daher keine übereinstimmenden Signaturen für den Funktionsstore (SOME_CLASS , ) haben (der Compiler wird manchmal nicht überlöst. . SOLE_FUNCTION hat nur den abgeleiteten Klasse Parameter SOLE_FUNCTION (SOME_CLASS &) (der gleiche Fall, den es oben versuchte, aber ich sehe keinen Grund, eine Funktion wie diese zu erfassen), oder wir können ein paar Problemumgehungen machen. /> Die Überladungs-Problemumgehung ist nicht so sauber wie Vorlagenabzug und es kann Fälle geben, in denen dies unpraktisch wird (für sehr große Mengen von Typen wird es mühsam, von Hand zu tippen), aber es wird funktionieren, wenn wir die Überladungen selbst wie SO erstellen: < /p>