Thread: Creating array of objects w/o default constructor

So, here's my code...

Code:

template <typename RandIter>
void compare_sorts (RandIter begin, RandIter end, double entropy = 0)
{
   using std::iterator_traits<RandIter>::value_type;
   value_type * manip_array;

   manip_array = new value_type[end - begin];
   std::copy (begin, end, manip_array);

   // ...
}

Now, my understanding is that whenever you create an array of objects, you automatically call the default constructor for each of the uninitialized values, so the code above calls the default constructor of value_type once for each element.

The thing is, immediately after creating the array, I assign in the iterated values. In principle, I should be able to rewrite the above code so that it creates manip_array using only the copy constructor.

Is it possible, and how?

I think Daved has the right idea... I was searching Josuttis' standard library book for an answer but could not find one that was suitable.

In fact, it would be simpler, in the sense that there is a constructor that takes a range, so there is no need to set the capacity then copy with a back inserter.

Sorry guys, but the vector solutions don't solve the problem at all. It still performs an initialization, followed by a bunch of assignment operations.

why not using dynamic array so you can perform polymorphism if you are doing some inheritance

Originally Posted by QuestionC

Sorry guys, but the vector solutions don't solve the problem at all. It still performs an initialization, followed by a bunch of assignment operations.

Not necessarily. Only if you use any of the forms which are explicitly documented to do this. If you don't, the contained type doesn't even need a default constructor. Thus:

Code:

template <typename RandIter>
void compare_sorts (RandIter begin, RandIter end, double entropy = 0)
{
   typedef typename std::iterator_traits<RandIter>::value_type value_type;
   typedef vector_type std::vector<value_type>;

   vector_type manip_array(begin, end);

   // ...
}

This doesn't need the default constructor and is even guaranteed (if RandIter really is random access) to allocate only once. Ergo you have zero overhead compared to the other form.

Ok, I didn't implement it correctly... calling the iterator constructor of vector does not call the assignment or default constructors.

Still, I would like to know how to do this. I'm not a fan of methods I don't understand, but the source for my compiler's implementation of Vector is arcane and undecipherable.

It's pretty simple. std::vector has a constructor that takes two iterators (a "range") as arguments. This constructor just initializes the vector with a copy of this range.

Or do you mean how it's implemented?

I mean, how one would implement it.

the answer to your topic is easy, as long as u keep it simple

Code:

Myclass* objects[10];

for(int i = 0; i < 10; i++)
objects = new Myclass(/*whether you have contructor or nor*/);

the answer to your topic is easy, as long as u keep it simple

That's not going to work for a vector though (only 10 elements?), and I doubt if vectors are typically implemented as a pointer to a pointer.