Gibt es ein Funktionsobjekt zum Erstellen von Objekten in AWL? Betrachten

Question

die folgende Klasse:

class Person { 
public: 
    // I don't want any "char *" to be converted to Person implicitly! 
    explicit Person(const char * name) : name_(name) {}; 

private: 
    std::string name_; 
}; 

Sehen Sie sich auch folgende Array von char * Daten:

char STUDENT_NAMES[][20] = { 
    "Bart", 
    "Liza", 
    "Maggie" 
}; 

Jetzt will ich std :: Liste der Person erstellen nach diesem Array. Alles, was ich erfinden könnte, ist std verwenden :: Transformationsalgorithmus mit handgeschriebenem Funktionsobjekt:

struct CreatePerson : public std::unary_function<const char*,Person> { 
    Person operator() (const char * name) const { 
     return Person(name); 
    }; 
}; 

// ... 

std::list<Person> students; 
std::transform(
    &STUDENT_NAMES[ 0 ], 
    &(STUDENT_NAMES[ sizeof(STUDENT_NAMES)/sizeof(STUDENT_NAMES[0]) ]), 
    front_inserter(students), 
    CreatePerson()); 
// ... 

Gibt es eine kürzer und/oder klare Weise es zu tun? Vielleicht einige Standard Funktionsobjekte oder Adapter?

Answer 1

Sie können boost::lambda auf folgende Weise verwenden:

#include <boost/lambda/lambda.hpp> 
#include <boost/lambda/construct.hpp> 
#include <string> 
#include <iterator> 
#include <algorithm> 
#include <list> 

struct person { 
    explicit person(char const *name) 
    :name(name) { } 
private: 
    std::string name; 
}; 

int main() { 
    char names[][20] = { 
    "Michael", "litb" 
    }; 

    std::list<person> v; 
    std::transform(names, names + 2, std::front_inserter(v), 
    boost::lambda::constructor<person>()); 
} 

Ich glaube nicht, dass es mit der Standard C++ Library eine solche Art und Weise ist.

Answer 2

nicht viel, ist aber nicht, dass es eine Standard-ELEMENTE-Makro für

sizeof(STUDENT_NAMES)/sizeof(STUDENT_NAMES[0]) 

Schnellsuche fand es nicht, aber ich fühle mich wie jede Implementierung ich verwendet habe, hat es.

Nur ein anderer Vorschlag, den ich habe, ist CreatePerson in eine Vorlage zu verwandeln - so, wenn Sie es noch einmal brauchen, müssen Sie nur CreateObj oder so etwas tun.

Answer 3

Nun ich habe gerade geschrieben eine Methode/Funktion wie:

convert(const char*[] names, std::list<Person>&); 

Warum nicht, wenn nur eine einfache Umwandlung zu tun? Vielleicht vermisse ich den Punkt?

m2c

Answer 4

Ihre Klasse Konstruktor ist eine Konvertierungsfunktion. Sie müssen nicht umwandeln: Sie können einfach einfügen. Werfen Sie einen Blick auf this code here.

std::list<Person> ps(NAMES, NAMES+sizeof(NAMES)/sizeof(NAMES[0])); 

Andernfalls eine kürzere Abhilfe wäre eine statische Factory-Funktion:

struct Person { 
    static Person create(const char* name); 
    .... 
}; 

std::transform(NAMES, NAMES+sizeof(NAMES)/sizeof(NAMES[0], front_inserter(ps), 
    &Person::create);