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?

You could use a vector instead of a dynamic array, set the proper capacity (not size), then copy with a back inserter.

You might also be able to do something complex with placement new, but I'm not sure that would be necessary.

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.

>> 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.

Good call.

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

Quote:

---

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.

>> 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.
Did you implement it correctly?

>> why not using dynamic array so you can perform polymorphism if you are doing some inheritance
A dynamic array has nothing to do with polymorphism. Are you suggesting that pointers be stored instead?

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?

Quote:

---

Originally Posted by QuestionC

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.

---

Code:

---

std::vector<T>(Iter start, Iter end)

---

This constructor uses copy constructors (or whatever can be used to implement making a copy).

A vector owns its objects, it will make a copy of the objects it is storing. Do you have a problem with that?

I mean, how one would implement it.

Why do you need to implement it?

You can look it up in the "vector" header, although it probably is not going to be nice reading.

I guess you want to make a copy of the data before passing it to various sort routines? So, you have random access iterators, why not use a vector?

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*/);

---

Quote:

---

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.

>> Still, I would like to know how to do this.
I believe they use placement new. So they allocate a block of memory large enough to hold the data (or perhaps a little larger). Then, they use placement new to construct (via the copy constructor) each element one at a time.

Sort of. They use the allocator's construct() method - but there is pretty much no other way to implement it but placement new.

I think I've figured out the essentials, although the code I have may be MSVC specific.

Code:

---

#include <new>
#include <iterator>
#include <iostream>
#include <memory>

class foo {
  public:
  foo() {
      std::cout << "Default\n";
  }

  foo (foo const &) {
      std::cout << "Copy\n";
  }

  foo (int i) {
      std::cout << "Int\n";
  }

  foo & operator= (foo const &) {
      std::cout << "Assign\n";
      return *this;
  }

  ~foo() {
      std::cout << "Destroy\n";
  }
};

template <class Iter>
typename std::iterator_traits<Iter>::value_type * make_array (Iter begin, Iter end) {
  std::cout << "Begin make_array\n";

  using std::iterator_traits<Iter>::value_type;
  std::allocator<value_type> alloc;
  value_type * result = alloc.allocate (end - begin);

  /*
  for (int i = 0; i < end - begin; ++i) {
      alloc.construct (result + i, begin[i]);
  }
  */
  std::uninitialized_copy (begin, end, result);

  std::cout << "End make_array\n";
 
  return  result;

}

int main (void) {
  foo * abc = new foo[3];
  for (int i = 0; i < 3; ++i) {
      abc[i] = i;
  }

  foo * asdf = make_array (abc, abc + 3);

  delete[] abc;

  /*
  // Doesn't work.  Would have to use custom de-allocation code for the array
  std::cout << "Begin array delete\n";
  delete[] asdf;
  std::cout << "End array delete\n";
  */

  return 0;

}

---

I get the feeling it's impossible to craft an array in the manner I'm looking for such that it can be freed using delete[]. Of course, if the custom allocation is contained in an Object, the custom destructor will be encapsulated anyhow.

Anyhow, here's the articles that were personally the most helpful
http://gcc.gnu.org/onlinedocs/libstd...allocator.html
http://www.scs.stanford.edu/~dm/home...s/c++-new.html

Quote:

---

Originally Posted by laserlight

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.

---

that's why I always prefer array as my official container :D they offer great functionality with pointers. And they push you (the programmer) to your limits

Quote:

---

that's why I always prefer array as my official container they offer great functionality with pointers.

---

I was talking about implementation, not functionality. Vectors can be used to store pointers too, of course, and provide pointer-like access with iterators.

Quote:

---

And they push you (the programmer) to your limits

---

Yes, your limits such that you do not take advantage of RAII ;)