Thread: Creating array of objects w/o default constructor

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

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 they offer great functionality with pointers. And they push you (the programmer) to your limits

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.

And they push you (the programmer) to your limits

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