Index: Bounded_Value_Allocation_Traits_T.h
===================================================================
--- Bounded_Value_Allocation_Traits_T.h	(revision 84476)
+++ Bounded_Value_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,11 @@
     return new value_type[MAX];
   }
 
+  inline static value_type * allocbuf_noinit(CORBA::ULong /* maximum */)
+  {
+    return new value_type[MAX];
+  }
+
   inline static void freebuf(value_type * buffer)
   {
     delete[] buffer;
Index: Object_Reference_Traits_T.h
===================================================================
--- Object_Reference_Traits_T.h	(revision 84476)
+++ Object_Reference_Traits_T.h	(working copy)
@@ -11,6 +11,7 @@
  * @author Carlos O'Ryan
  */
 #include "Object_Reference_Traits_Base_T.h"
+#include "ace/OS_NS_string.h"
 
 #include <algorithm>
 #include <functional>
@@ -33,7 +34,7 @@
   inline static void zero_range(
       object_type ** begin, object_type ** end)
   {
-    std::fill(begin, end, derived::nil());
+    ACE_OS::memset (begin, 0, (end - begin) * sizeof (object_type*));
   }
 
   inline static void initialize_range(
@@ -58,6 +59,22 @@
   }
 # endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
 
+#ifndef ACE_LACKS_MEMBER_TEMPLATES
+  // Allow MSVC++ >= 8 checked iterators to be used.
+  template <typename iter>
+  inline static void copy_swap_range(
+      object_type ** begin, object_type ** end, iter dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#else
+  inline static void copy_swap_range(
+      object_type ** begin, object_type ** end, object_type ** dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
+
   inline static void release_range(
       object_type ** begin, object_type ** end)
   {
Index: Bounded_Sequence_CDR_T.h
===================================================================
--- Bounded_Sequence_CDR_T.h	(revision 84476)
+++ Bounded_Sequence_CDR_T.h	(working copy)
@@ -305,6 +305,7 @@
   bool demarshal_sequence(stream & strm, TAO::bounded_basic_string_sequence <charT, MAX> & target) {
     typedef typename TAO::bounded_basic_string_sequence <charT, MAX> sequence;
     typedef typename sequence::element_traits::string_var string_var;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -312,8 +313,9 @@
     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
       return false;
     }
-    sequence tmp;
-    tmp.length(new_length);
+    sequence tmp(new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       string_var string;
       if (!(strm >> string.inout ())) {
@@ -331,6 +333,7 @@
   bool demarshal_sequence(stream & strm, TAO::bounded_bd_string_sequence <charT, MAX, BD_STR_MAX> & target) {
     typedef typename TAO::bounded_bd_string_sequence <charT, MAX, BD_STR_MAX> sequence;
     typedef typename sequence::element_traits::string_var string_var;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -338,8 +341,9 @@
     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
       return false;
     }
-    sequence tmp;
-    tmp.length(new_length);
+    sequence tmp(new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       string_var string;
       if (!(strm >> string.inout ())) {
@@ -360,6 +364,7 @@
   template <typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>
   bool demarshal_sequence(stream & strm, TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> & target) {
     typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> sequence;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -367,8 +372,9 @@
     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
       return false;
     }
-    sequence tmp;
-    tmp.length(new_length);
+    sequence tmp(new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     typename sequence::value_type * buffer = tmp.get_buffer();
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       if (!(strm >> buffer[i])) {
Index: Bounded_Array_Allocation_Traits_T.h
===================================================================
--- Bounded_Array_Allocation_Traits_T.h	(revision 84476)
+++ Bounded_Array_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,11 @@
     return new value_type[MAX];
   }
 
+  inline static value_type * allocbuf_noinit(CORBA::ULong /* maximum */)
+  {
+    return new value_type[MAX];
+  }
+
   inline static void freebuf(value_type * buffer)
   {
     delete[] buffer;
Index: Unbounded_Octet_Sequence_T.h
===================================================================
--- Unbounded_Octet_Sequence_T.h	(revision 84476)
+++ Unbounded_Octet_Sequence_T.h	(working copy)
@@ -128,7 +128,7 @@
     return length_;
   }
   inline void length(CORBA::ULong length) {
-    if (length <= maximum_ || length <= length_)
+    if (length <= maximum_)
       {
         if (this->mb_ == 0)
           {
Index: Unbounded_Value_Allocation_Traits_T.h
===================================================================
--- Unbounded_Value_Allocation_Traits_T.h	(revision 84476)
+++ Unbounded_Value_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,11 @@
     return new value_type[maximum];
   }
 
+  inline static value_type * allocbuf_noinit(CORBA::ULong maximum)
+  {
+    return new value_type[maximum];
+  }
+
   inline static void freebuf(value_type * buffer)
   {
     delete[] buffer;
Index: Unbounded_Sequence_CDR_T.h
===================================================================
--- Unbounded_Sequence_CDR_T.h	(revision 84476)
+++ Unbounded_Sequence_CDR_T.h	(working copy)
@@ -341,6 +341,7 @@
   bool demarshal_sequence(stream & strm, TAO::unbounded_basic_string_sequence <charT> & target) {
     typedef TAO::unbounded_basic_string_sequence <charT> sequence;
     typedef typename sequence::element_traits::string_var string_var;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -348,8 +349,9 @@
     if (new_length > strm.length()) {
       return false;
     }
-    sequence tmp(new_length);
-    tmp.length(new_length);
+    sequence tmp(new_length, new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       string_var string;
       if (!(strm >> string.inout ())) {
@@ -367,6 +369,7 @@
   bool demarshal_sequence(stream & strm, TAO::unbounded_bd_string_sequence <charT, BD_STR_MAX> & target) {
     typedef TAO::unbounded_bd_string_sequence <charT, BD_STR_MAX> sequence;
     typedef typename sequence::element_traits::string_var string_var;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -374,8 +377,9 @@
     if (new_length > strm.length()) {
       return false;
     }
-    sequence tmp(new_length);
-    tmp.length(new_length);
+    sequence tmp(new_length, new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       string_var string;
       if (!(strm >> string.inout ())) {
@@ -396,6 +400,7 @@
   template <typename stream, typename object_t, typename object_t_var>
   bool demarshal_sequence(stream & strm, TAO::unbounded_object_reference_sequence<object_t, object_t_var> & target) {
     typedef TAO::unbounded_object_reference_sequence<object_t, object_t_var> sequence;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -403,8 +408,9 @@
     if (new_length > strm.length()) {
       return false;
     }
-    sequence tmp(new_length);
-    tmp.length(new_length);
+    sequence tmp(new_length, new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     typename sequence::value_type * buffer = tmp.get_buffer();
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       if (!(strm >> buffer[i])) {
Index: Unbounded_Reference_Allocation_Traits_T.h
===================================================================
--- Unbounded_Reference_Allocation_Traits_T.h	(revision 84476)
+++ Unbounded_Reference_Allocation_Traits_T.h	(working copy)
@@ -42,6 +42,17 @@
     reinterpret_cast<value_type**>(buffer)[0] = buffer + maximum + 1;
 
     // no throw
+    reference_traits::initialize_range(buffer + 1, buffer + maximum + 1);
+
+    return buffer + 1;
+  }
+
+  inline static value_type * allocbuf_noinit(CORBA::ULong maximum)
+  {
+    value_type * buffer = new value_type[maximum + 1];
+    reinterpret_cast<value_type**>(buffer)[0] = buffer + maximum + 1;
+
+    // no throw
     reference_traits::zero_range(buffer + 1, buffer + maximum + 1);
 
     return buffer + 1;
Index: Unbounded_Array_Allocation_Traits_T.h
===================================================================
--- Unbounded_Array_Allocation_Traits_T.h	(revision 84476)
+++ Unbounded_Array_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,11 @@
     return new value_type[maximum];
   }
 
+  inline static value_type * allocbuf_noinit(CORBA::ULong maximum)
+  {
+    return new value_type[maximum];
+  }
+
   inline static void freebuf(value_type * buffer)
   {
     delete[] buffer;
Index: String_Traits_T.h
===================================================================
--- String_Traits_T.h	(revision 84476)
+++ String_Traits_T.h	(working copy)
@@ -11,6 +11,7 @@
  */
 
 #include "String_Traits_Base_T.h"
+#include "ace/OS_NS_string.h"
 
 #include <algorithm>
 #include <functional>
@@ -31,7 +32,7 @@
   inline static void zero_range(
       char_type ** begin, char_type ** end)
   {
-    std::fill(begin, end, static_cast<char_type*>(0));
+    ACE_OS::memset (begin, 0, (end - begin) * sizeof (char_type*));
   }
 
   inline static void initialize_range(
@@ -56,6 +57,22 @@
   }
 # endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
 
+#ifndef ACE_LACKS_MEMBER_TEMPLATES
+  // Allow MSVC++ >= 8 checked iterators to be used.
+  template <typename iter>
+  inline static void copy_swap_range(
+      char_type ** begin, char_type ** end, iter dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#else
+  inline static void copy_swap_range(
+      char_type ** begin, char_type ** end, char_type ** dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
+
   inline static void release_range(
       char_type ** begin, char_type ** end)
   {
Index: Value_Traits_T.h
===================================================================
--- Value_Traits_T.h	(revision 84476)
+++ Value_Traits_T.h	(working copy)
@@ -11,6 +11,8 @@
  * @author Carlos O'Ryan
  */
 
+#include "ace/OS_NS_string.h"
+
 #include <algorithm>
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
@@ -29,7 +31,7 @@
   inline static void zero_range(
       value_type * begin , value_type * end)
   {
-    std::fill(begin, end, value_type ());
+    ACE_OS::memset (begin, 0, (end - begin) * sizeof (value_type));
   }
 
   inline static void initialize_range(
@@ -59,6 +61,22 @@
     std::copy(begin, end, dst);
   }
 # endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
+
+#ifndef ACE_LACKS_MEMBER_TEMPLATES
+  // Allow MSVC++ >= 8 checked iterators to be used.
+  template <typename iter>
+  inline static void copy_swap_range(
+      value_type * begin, value_type * end, iter dst)
+  {
+    copy_range(begin, end, dst);
+  }
+#else
+  inline static void copy_swap_range(
+      value_type * begin, value_type * end, value_type * dst)
+  {
+    copy_range(begin, end, dst);
+  }
+#endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
 };
 
 } // namespace details
Index: Generic_Sequence_T.h
===================================================================
--- Generic_Sequence_T.h	(revision 84476)
+++ Generic_Sequence_T.h	(working copy)
@@ -117,8 +117,9 @@
     , release_(false)
   {
     if (rhs.maximum_ == 0) return;
-    generic_sequence tmp(rhs.maximum_);
-    tmp.length_ = rhs.length_;
+    generic_sequence tmp(rhs.maximum_, rhs.length_,
+                         allocation_traits::allocbuf_noinit(rhs.length_),
+                         true);
     element_traits::copy_range(
         rhs.buffer_,
         rhs.buffer_ + rhs.length_,
@@ -164,12 +165,16 @@
   /// Set a new length for the sequence
   void length(CORBA::ULong length)
   {
-    if (length <= maximum_ || length <= length_)
+    if (length <= maximum_)
     {
       if (buffer_ == 0)
         {
           buffer_ = allocbuf(maximum_);
           release_ = true;
+          length_ = length;
+          // Since allocbuf returns completely initialized buffer
+          // no further actions are required.
+          return;
         }
 
     if (length < length_)
@@ -190,9 +195,10 @@
       return;
     }
 
-    generic_sequence tmp(length);
-    tmp.length_ = length;
-    element_traits::copy_range(
+    generic_sequence tmp(length, length,
+                         allocation_traits::allocbuf_noinit(length),
+                         true);
+    element_traits::copy_swap_range(
       buffer_,
       buffer_ + length_,
       ACE_make_checked_array_iterator (tmp.buffer_, tmp.length_));
Index: Valuetype/Bounded_Valuetype_Allocation_Traits_T.h
===================================================================
--- Valuetype/Bounded_Valuetype_Allocation_Traits_T.h	(revision 84476)
+++ Valuetype/Bounded_Valuetype_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,15 @@
   {
     value_type * buffer = new value_type[MAX];
     // no throw
+    valuetype_traits::initialize_range(buffer, buffer + MAX);
+
+    return buffer;
+  }
+
+  inline static value_type * allocbuf_noinit(CORBA::ULong /* maximum */)
+  {
+    value_type * buffer = new value_type[MAX];
+    // no throw
     valuetype_traits::zero_range(buffer, buffer + MAX);
 
     return buffer;
Index: Valuetype/Bounded_Valuetype_Sequence_T.h
===================================================================
--- Valuetype/Bounded_Valuetype_Sequence_T.h	(revision 84476)
+++ Valuetype/Bounded_Valuetype_Sequence_T.h	(working copy)
@@ -117,6 +117,7 @@
   template <typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>
   bool demarshal_sequence(stream & strm, TAO::bounded_valuetype_sequence<object_t, object_t_var, MAX> & target) {
     typedef TAO::bounded_valuetype_sequence<object_t, object_t_var, MAX> sequence;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -124,8 +125,9 @@
     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
         return false;
     }
-    sequence tmp;
-    tmp.length(new_length);
+    sequence tmp(new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     typename sequence::value_type * buffer = tmp.get_buffer();
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       if (!(strm >> buffer[i])) {
Index: Valuetype/Unbounded_Valuetype_Sequence_T.h
===================================================================
--- Valuetype/Unbounded_Valuetype_Sequence_T.h	(revision 84476)
+++ Valuetype/Unbounded_Valuetype_Sequence_T.h	(working copy)
@@ -118,6 +118,7 @@
   template <typename stream, typename object_t, typename object_t_var>
   bool demarshal_sequence(stream & strm, TAO::unbounded_valuetype_sequence <object_t, object_t_var> & target) {
     typedef typename TAO::unbounded_valuetype_sequence <object_t, object_t_var> sequence;
+    typedef typename sequence::allocation_traits sequence_allocation_traits;
     ::CORBA::ULong new_length = 0;
     if (!(strm >> new_length)) {
       return false;
@@ -125,8 +126,9 @@
     if (new_length > strm.length()) {
         return false;
     }
-    sequence tmp(new_length);
-    tmp.length(new_length);
+    sequence tmp(new_length, new_length,
+                 sequence_allocation_traits::allocbuf_noinit(new_length),
+                 true);
     typename sequence::value_type * buffer = tmp.get_buffer();
     for(CORBA::ULong i = 0; i < new_length; ++i) {
       if (!(strm >> buffer[i])) {
Index: Valuetype/Unbounded_Valuetype_Allocation_Traits_T.h
===================================================================
--- Valuetype/Unbounded_Valuetype_Allocation_Traits_T.h	(revision 84476)
+++ Valuetype/Unbounded_Valuetype_Allocation_Traits_T.h	(working copy)
@@ -42,6 +42,17 @@
     reinterpret_cast<value_type**>(buffer)[0] = buffer + maximum + 1;
 
     // no throw
+    valuetype_traits::initialize_range(buffer + 1, buffer + maximum + 1);
+
+    return buffer + 1;
+  }
+
+  inline static value_type * allocbuf_noinit(CORBA::ULong maximum)
+  {
+    value_type * buffer = new value_type[maximum + 1];
+    reinterpret_cast<value_type**>(buffer)[0] = buffer + maximum + 1;
+
+    // no throw
     valuetype_traits::zero_range(buffer + 1, buffer + maximum + 1);
 
     return buffer + 1;
Index: Valuetype/Valuetype_Traits_T.h
===================================================================
--- Valuetype/Valuetype_Traits_T.h	(revision 84476)
+++ Valuetype/Valuetype_Traits_T.h	(working copy)
@@ -10,6 +10,7 @@
  * @author Carlos O'Ryan
  */
 #include "Valuetype_Traits_Base_T.h"
+#include "ace/OS_NS_string.h"
 
 #include <algorithm>
 #include <functional>
@@ -32,7 +33,7 @@
   inline static void zero_range(
       object_type ** begin, object_type ** end)
   {
-    std::fill(begin, end, derived::nil());
+    ACE_OS::memset (begin, 0, (end - begin) * sizeof (object_type*));
   }
 
   inline static void initialize_range(
@@ -57,6 +58,22 @@
   }
 #endif  /* ACE_LACKS_MEMBER_TEMPLATES */
 
+#ifndef ACE_LACKS_MEMBER_TEMPLATES
+  // Allow MSVC++ >= 8 checked iterators to be used.
+  template <typename iter>
+  inline static void copy_swap_range(
+      object_type ** begin, object_type ** end, iter dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#else
+  inline static void copy_swap_range(
+      object_type ** begin, object_type ** end, object_type ** dst)
+  {
+    std::swap_ranges(begin, end, dst);
+  }
+#endif  /* ACE_LACKS_MEMBER_TEMPLATES */
+
   inline static void release_range(
       object_type ** begin, object_type ** end)
   {
Index: Bounded_Reference_Allocation_Traits_T.h
===================================================================
--- Bounded_Reference_Allocation_Traits_T.h	(revision 84476)
+++ Bounded_Reference_Allocation_Traits_T.h	(working copy)
@@ -40,6 +40,15 @@
   {
     value_type * buffer = new value_type[MAX];
     // no throw
+    reference_traits::initialize_range(buffer, buffer + MAX);
+
+    return buffer;
+  }
+
+  inline static value_type * allocbuf_noinit(CORBA::ULong /* maximum */)
+  {
+    value_type * buffer = new value_type[MAX];
+    // no throw
     reference_traits::zero_range(buffer, buffer + MAX);
 
     return buffer;
Index: Array_Traits_T.h
===================================================================
--- Array_Traits_T.h	(revision 84476)
+++ Array_Traits_T.h	(working copy)
@@ -69,6 +69,7 @@
     std::for_each(
         begin, end, &TAO::Array_Traits<forany_type>::zero);
   }
+
 # ifndef ACE_LACKS_MEMBER_TEMPLATES
   // Allow MSVC++ >= 8 checked iterators to be used.
   template <typename iter>
@@ -90,6 +91,22 @@
     }
   }
 # endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
+
+#ifndef ACE_LACKS_MEMBER_TEMPLATES
+  // Allow MSVC++ >= 8 checked iterators to be used.
+  template <typename iter>
+  inline static void copy_swap_range(
+      value_type * begin, value_type * end, iter dst)
+  {
+    copy_range(begin, end, dst);
+  }
+#else
+  inline static void copy_swap_range(
+      value_type * begin, value_type * end, value_type *dst)
+  {
+    copy_range(begin, end, dst);
+  }
+#endif  /* !ACE_LACKS_MEMBER_TEMPLATES */
 };
 
 } // namespace details