Question

let’s assume that I have some codes like this. What should I write there in order to have a constructor that initializes a Foo typed object. Thanks. this is the example I am trying to understand http://flylib.com/books/en/2.674.1.140/1/ sorry for the delay.

class Foo
{
private:
   set<int*> numbers;
public:
   //constuctor
   Foo(set<int*>& numb = "what to write here?"): numbers("something") {};

};

Answer 1

Having a set of pointers usually isn’t what you want. sets are a collection of unique items, but a set of pointers means each pointer will be unique, not the values they point to.

Steve Jessop points out some more reasons not to want a container of pointers. For one, it’s not clear who owns the pointers at what point, and so it’s not clear how to handle errors. Part of sorting that out could mean imposing stricter requirements on the pointers, for example requiring them to be new allocated so that the object taking ownership knows how to release them. Such requirements will probably only be enforced by manual inspection of the code and documentation, and so will be error prone. That could be improved on by using smart pointers instead of raw pointers.

But if for some reason you really do want this with raw pointers, then:

   Foo(set<int*> const &numb = set<int*>()): numbers(numb) {}

Or use overloading instead:

   Foo() {} // default constructs numbers
   Foo(set<int*> const &numb) : numbers(numb) {}

Or if you really want to construct numbers as a non-empty set by default you can do the following (dangerous, leak prone) things:

   Foo(set<int*> const &numb = set<int*>()) : numbers(numb) {
       if(numbers.empty()) { // this also prevents the user from being able to make the set empty
           numbers.insert(new int(0));
           numbers.insert(new int(0));
       }
   }

Or using C++11:

   Foo(set<int*> const &numb = set<int*>{new int(0),new int(0)} ) : numbers(numb) {} // uses default argument value with brace initializer list style

or

   Foo(set<int*> const &numb) : numbers(numb) {}
   Foo() : Foo(set<int*>{new int(0),new int(0)}) {} // uses delegating constructors

Fixing the leaks above using smart pointers yields something like:

   Foo(set<unique_ptr<int>> const &numb = set<unique_ptr<int>>()) : numbers(numb) {
       if(numbers.empty()) { // this also prevents the user from being able to make the set empty
           numbers.insert(unique_ptr<int>(new int(0)));
           numbers.insert(unique_ptr<int>(new int(0)));
       }
   }

Using brace initialization with smart pointers like the following still has the possibility for leaks:

   Foo(set<unique_ptr<int>> const &numb = set<int*>{unique_ptr<int>(new int(0)),unique_ptr<int>(new int(0))} ) : numbers(numb) {}

So instead you should use a helper function to produce the default value:

class Foo
{
private:
    set<unique_ptr<int>> numbers;
    static set<unique_ptr<int>> default_set() {
        set<unique_ptr<int>> the_default;
        the_default.insert(unique_ptr<int>(new int(0)));
        the_default.insert(unique_ptr<int>(new int(0)));
        return the_default;
    }
public:
    // using default arg
    Foo(set<unique_ptr<int>> &&numb = default_set()) : numbers(move(numb)) {};

    // or delegating constructors
    Foo(set<unique_ptr<int>> &&numb) : numbers(move(numb)) {};
    Foo() : Foo(default_set()) {}

    // in addition to one of the above you probably want a constructor that takes a non-rvalue-reference and copies it
    Foo(set<unique_ptr<int>> numb) : Foo(move(numb)) {}; // copy is implicit, we delegate moving that copy into number to the ctor that takes an rvalue-reference. You could also just initialize numbers here directly.

};