Ableitung des Rückgabetyps einer Funktion oder eines Funktors in C++

Question

Ich muss den Rückgabewert einer Funktion/eines Funktors verwenden, ohne zu wissen, um welchen Typ es sich handelt (d. h. als Vorlage).

Ich konnte sie aber problemlos an eine zweite Funktion weitergeben:

template <typename T>
void DoSomething(T value);

...

DoSomething(FunctionWhoseReturnedTypeIsUnknown(...));

Ich möchte den zurückgegebenen Wert inline verwenden (ohne eine zweite Funktion aufrufen zu müssen):

WhatGoesHere? x=FunctionWhoseReturnedTypeIsUnknown(...);

Die beiden Methoden scheinen mir konzeptionell identisch zu sein (in Bezug auf die generische Programmierung), aber kann letzteres in C++ erreicht werden?

Answer 1

Bis das auto-Schlüsselwort es wirklich trivial macht, kann man sich auf die Konvention verlassen, dass Funktionsobjekte bestimmte typedef's bereitstellen, einschließlich result_type. Man muss nur eine einfache Funktion in ein Funktionsobjekt verpacken. Der standardmäßige "funktionale" Header stellt einige zur Verfügung (pointer_to_unary_function/pointer_to_binary_function zusätzlich zu einer Reihe von Wrappern für Mitgliedsfunktionen). Wenn diese nicht ausreichen, bietet die boost-Bibliothek noch leistungsfähigere Wrapper.

#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>

int answer()
{
    return 42;
}

template <class T>
T unknown()
{
    return T();
}

template <class Function>
void foobar(Function unknown)
{
    typename Function::result_type x = unknown();
    std::cout << x << '\n';
}

int main()
{
    foobar(boost::function<int()>(answer));
    foobar(boost::bind(unknown<int>));
}

Und hier ein Beispiel, wie Sie eine Pointer_to_zeronary_function hinzufügen könnten. (Ich nehme an, dass die Hilfsfunktion ptr_fun, die bei der Erstellung einer solchen Funktion hilft, dem Standard-Namensraum hinzugefügt werden könnte, ebenso wie eine Überladung(?)

template <class T>
class pointer_to_zeronary_function
{
    typedef T(*zeronary_func)();
    zeronary_func func;
public:
    typedef T result_type;
    pointer_to_zeronary_function(zeronary_func f): func(f) {}
    T operator()() const
    {
        return func();
    }
};

template <class T>
pointer_to_zeronary_function<T> ptr_fun(T(*f)())
{
    return pointer_to_zeronary_function<T>(f);
}

...
//usage:
foobar(ptr_fun(answer));

Answer 2

Noch nicht. In C++0X werden Sie in der Lage sein, die auto als WhatGoesHere . Es gibt bereits experimentelle Unterstützung für diese in einigen Compilern (gcc 4.4 zum Beispiel).

Answer 3

Es hängt von Ihrem speziellen Anwendungsfall ab, aber manchmal boost::any verwendet werden können:

#include <iostream>
#include <boost/any.hpp>

namespace {
  template <class T>
  T return_arg(T t) {
    return t;
  }
}

int main() {
  try {  
    boost::any i = return_arg(1);
    boost::any s = return_arg("a string");
    std::cout << boost::any_cast<int>(i) << " "
          << boost::any_cast<const char*>(s)
          << std::endl;
  }
  catch(const boost::bad_any_cast &) {
      return 1;
  }
}

Answer 4

C++0x führt das Konzept eines abgeleiteten Variablentyps mit dem Schlüsselwort auto ein.

auto x = SomeFunction();

Das Ergebnis ist dasselbe wie das var-Schlüsselwort von C#: eine stark typisierte Variable, deren Typ dem Rückgabetyp des Ausdrucks entspricht.

In Ermangelung von C++0x gibt es keine gute Möglichkeit, dies außerhalb einer Vorlage zu erreichen. Gäbe es Wege, würde C++0x diese Funktion nicht benötigen.