Question

I’m implementing an STL set with a complex template parameter type. When inserting in to the set, I want the set to use the less-than operator I’ve defined for my type. I also want to minimize the quantity of object instantiations of my type. It seems I can’t have both.

I’ve got two minimal examples below, each uses the same C++ class.

#include <iostream>
#include <set>

using namespace std;

class Foo {
    public:
        Foo(int z);
        Foo(const Foo &z);
        bool operator<(const Foo &rhs) const;
        int a;
};

Foo::Foo(int z)
{
    cout << "cons" << endl;
    a = z;
}

Foo::Foo(const Foo &z)
{
    cout << "copy cons" << endl;
    a = z.a;
}

bool
Foo::operator<(const Foo &rhs) const
{
    cout << "less than" << endl;
    return a < rhs.a;
}

Here’s my first main():

int
main(void)
{
    set<Foo> s;

    s.insert(*new Foo(1));
    s.insert(*new Foo(2));
    s.insert(*new Foo(1));

    cout << "size: " << s.size() << endl;

    return 0;
}

That’s great because it uses the less-than I’ve defined for my class, and thus the size of the set is correctly two. But it’s bad because every insertion in to the set requires the instantiation of two objects (constructor, copy constructor).

$ ./a.out
cons
copy cons
cons
less than
less than
less than
copy cons
cons
less than
less than
less than
size: 2

Here’s my second main():

int
main(void)
{
    set<Foo *> s;

    s.insert(new Foo(1));
    s.insert(new Foo(2));
    s.insert(new Foo(1));

    cout << "size: " << s.size() << endl;

    return 0;
}

That’s great because an insertion requires just one object instantiation. But it’s bad because it’s really a set of pointers, and thus the uniqueness of set members is gone as far as my type is concerned.

$ ./a.out
cons
cons
cons
size: 3

I’m hoping there’s some bit of information I’m missing. Is it possible for me to have both minimal object instantiations and appropriate sorting?

Answer 1

You are getting a copy from this: *new Foo(1).

Create this struct:

template<typename T>
struct PtrLess
{
    bool operator()(const T *a, const T *b) const
    {
        return *a < *b;
    }
};

Make the map look like set<Foo*, PtrLess<Foo>> s; and then add Foo’s like s.insert(new Foo(1));
Note the *

Otherwise, when the map creates a container for the Foo item, since it is allocated within the foo containers definition, the map has to copy the supplied value into its internal Foo object.