Is there any function object to create objects in STL?

Question

Consider the following class:

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_;
};

Also consider following array of char* data:

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

Now, I want to create std::list of Person according to this array. All I could invent is to use std::transform algorithm with hand-written function object:

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() );
// ...

Is there any shorter and/or clearer way to do it? Maybe some standard function objects or adaptors?

Answer 1

You may use boost::lambda in the following way:

#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>());
}

I don't think there is such a way with the Standard C++ Library.

Answer 2

Not much help, but isn't there a standard ELEMENTS macro for

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

Quick search didn't find it, but I feel like every implementation I have used has it.

Only other suggestion I have is to turn CreatePerson into a template -- that way, if you need it again, you just need to do CreateObj or something like that.

Answer 3

Well I will just have written a method/function like :

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

Why not if just to do a simple conversion ? Maybe I miss the point ?

m2c

Answer 4

Your class' constructor is a conversion function. You don't need to transform: you can just insert. Take a look at this code here.

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

Otherwise, a shorter workaround would be using a static factory function:

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

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