stl vector and c++: how to .resize without a default constructor?

Question

how could I tell STL, specifically for the method resize() in vector, to initialize objects with a constructor other than default, and with which parameters?

I mean:

class something {
    int a;
    something (int value);
}

std::vector<something> many_things;

many_things.resize (20);

more generally, how could I force STL to use my costructor when it needs to create objects, and pass parameters to that constructor?

in my case adding a default constructor is not an option, and I'd prefer not to use an array of pointers to solve the problem.

thanks =)!

Answer 1

You could use reserve() to increase the buffer size and manually add (push_back()) the necessary items in a loop.

Answer 2

Use the 2-argument overload: many_things.resize(20, something(5));

Answer 3

With specialization alike this (sorry, I wrote this with only minimal checks)?

#include <vector>

class MyClass
{
    private:
        MyClass();
    public:
        MyClass(unsigned i) : _data(i) {};

    private:
        unsigned _data;
};

typedef std::vector<MyClass> MyVector;

void MyVector::resize(MyVector::size_type new_size)
{
    this->resize(new_size, MyClass(5));
}

int main()
{
    MyVector vector;
    vector.resize(5);

    return 0;
}

But think if you really need it. Why not to create default constructor instead?

Answer 4

I can think of a solution, but iwarn you, it's rather ugly. I don't know why you do not want to add a default constructor, but if you just want to prevent users of the class to create unintialized instances, you can just make the default constructor private and declare the appropriate vector class a friend :

class Foo {
public:
   Foo( int x ) : num( x ) {}

   int GetX( ) { return num; }
private:
   friend class std::vector< Foo >;

   int num;
   Foo( ) : num( 10 ) {}
};

This is ugly for several reasons, mostly because it only works for one container type. There is no other way, because STL containers simply require their items to be default constructible.