Was ist das C++ - Äquivalent einer java.util.function.Supplier?

Question

Zum Beispiel habe ich den folgenden Java-Code:

public class Main { 
    public static void main(String[] args) { 
    System.out.println(maker(Employee::new)); 
    } 

    private static Employee maker(Supplier<Employee> fx) { 
    return fx.get(); 
    } 
} 

class Employee { 
    @Override 
    public String toString() { 
    return "A EMPLOYEE"; 
    } 
} 

Was wird die C++ gleichwertig sein?

Answer 1

Lieferant ist eine Funktion ohne Argumente und eine Art Rückkehr: Sie können darstellen, dass mit std::function:

#include <iostream> 
#include <functional> 
#include <memory> 

// the class Employee with a "print" operator 

class Employee 
{ 
    friend std::ostream& operator<<(std::ostream& os, const Employee& e); 
}; 

std::ostream& operator<<(std::ostream& os, const Employee& e) 
{ 
    os << "A EMPLOYEE"; 
    return os; 
} 

// maker take the supplier as argument through std::function 

Employee maker(std::function<Employee(void)> fx) 
{ 
    return fx(); 
} 

// usage 

int main() 
{ 
    std::cout << maker(
     []() { return Employee(); } 
      // I use a lambda here, I could have used function, functor, method... 
    ); 

    return 0; 
} 

ich nicht hier Zeiger verwendet haben noch der Betreiber neue Mitarbeiter zuweisen: Wenn Sie verwenden möchten,

std::unique_ptr<Employee> maker(std::function<std::unique_ptr<Employee>(void)> fx) 
{ 
    return fx(); 
} 

// ... 

maker(
    []() 
    { 
     return std::make_unique<Employee>(); 
    } 
); 

Hinweis: es sollten Sie Zeiger wie std::unique_ptr verwaltet betrachten den Anruf an Operator < < dann geändert werden sollte, weil Hersteller einen Zeiger anstelle eines Objekts zurück.

Answer 2

können Sie C++ Template-Klasse verwenden, um das Ziel zu erreichen:

template<typename TR> class Supplier 
{ 
    private: 
    TR (*calcFuncPtr)(); 

    public: 
    Supplier(TR(*F)()) 
    { 
     calcFuncPtr = F; 
    } 

    TR get() const 
    { 
     return calcFuncPtr(); 
    } 
}; 

Nutzungs Beispiel:

#include <string> 
#include <iostream> 

struct Employee 
{ 
    public: 
    std::string ToString() 
    { 
     return "A EMPLOYEE"; 
    } 
}; 

Employee maker(const Supplier<Employee>& fx) 
{ 
    return fx.get(); 
} 


Employee GetInstanceFunc() 
{ 
    return Employee(); 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    Employee employee(maker(GetInstanceFunc)); 
    std::cout << employee.ToString(); 
    return 0; 
} 

Implizite Typumwandlung in Zeile maker(GetInstanceFunc) ermöglicht Supplier Klasse ohne explizite Template-Instantiierung zu verwenden.