int aaa[3]={1,2,3};

class A
{
public:
    A():arr_()
    {
    }
private:
    int arr_[10];
};

#pragma pack(1)
struct triplet
{
   triplet(double x, double y, double z) : x(x), y(y), z(z) 
   {
   }

   explicit triplet(double p[3]) : x(p[0]), y(p[1]), z(p[2]) 
   {
   }

   operator double* const()
   {
       return &x; 
   }

   operator const double* const() const
   {
      return &x; 
   }

   double x;
   double y;
   double z;
};
#pragma pack()

class A
{
   triplet arr;

public:

   A(double x, double y, double z) : arr(x, y, z) {}
};

B>Я пару недель назад такую же ошибку допустил — спасибо комрад Кодт поправил

#ifdef _MSV_VER
#pragma pack( push, 1 )
#else
#pragma pack( 1 )
#endif
...

#ifdef _MSV_VER
#pragma pack( pop )
#else
#pragma pack( 1 )
#endif

HANDLE_PRAGMA_PACK_PUSH_POP
Define this macro (to a value of 1) if you want to support the Win32 style pragmas `#pragma pack(push,<n>)' and `#pragma pack(pop)'. The pack(push,<n>) pragma specifies the maximum alignment (in bytes) of fields within a structure, in much the same way as the `__aligned__' and `__packed__' __attribute__s do. A pack value of zero resets the behaviour to the default. Successive invocations of this pragma cause the previous values to be stacked, so that invocations of `#pragma pack(pop)' will return to the previous value.

S>    int aaa[3]={1,2,3};
S>

S>А если атрибут

class A
{
 int aaa[3];
 static int _init_(A* pA)
 {
  static int _init_aaa[3]={1,2,3};
  for(int i=0;i<sizeof(_init_aaa_)/sizeof(int);i++)
   pA->aaa[i]=_init_aaa[i];
 }
public:
 A() { _init_(this); }
};

class A
{
   int a[3];

public:
   A() 
   {
      a[0] = 1; a[1] = 2; a[2] = 3;
   }
}; // class A..

Class array fulfills most but not all of the requirements of "reversible containers" (see Section 23.1, [lib.container.requirements] of the C++ Standard). The reasons array is not an reversible STL container is because:
— No constructors are provided
— Elements may have an undetermined initial value (see below)
— swap() has no constant complexity
— size() is always constant, based on the second template argument of the type
— The container provides no allocator support

It doesn't fulfill the requirements of a "sequence" (see Section 23.1.1, [lib.sequence.reqmts] of the C++ Standard), except that
— front() and back() are provided
— operator[] and at() are provided

Regarding the constructors there was an important design tradeoff: We could implement array as an "aggregate" (see Section 8.5.1, [dcl.init.aggr], of the C++ Standard). This would mean:

An array can be initialized with a brace-enclosing, comma-separated list of initializers for the elements of the container, written in increasing subscript order:

boost::array<int,4> a = { { 1, 2, 3 } };

Note that if there are fewer elements in the initializer list, then each remaining element gets default-initialized (thus, it has a defined value).

However, passing no initializer list means that the elements have an indetermined initial value.
It has no user-declared constructors.
It has no private or protected non-static data members.
It has no base classes.
It has no virtual functions.
The current implementation uses this approach. However, being able to have indeterminate initial values is a big drawback. So, please give me some feedback, how useful you consider this feature to be. This leads to the list of Open issues:

Do we want initializer list support or would the following be OK?:

int data[] = { 1, 2, 3, 4 }

array<int,5> x(data); or   array<int,data> x;

Could "{ ... }" be used portably instead of "{ { ... } }" to initialize values?
8.5.1 (11) of the Standard seems to allow it; however, gcc 2.95.2 prints a warning message.

Any way to have determinate initial values and initializer list support?
Static_casts for reverse iterator stuff?

template<class T, size_t N>
class goodarray
{
  char buf_[N*sizeof(T)];
public:
  // вся шняга для совместимости с STL - пропущена
  iterator begin() { return (T*) buf_; }
  const_iterator begin() const { return (const T*) buf_; }

  ~goodarray()
  {
    placement_delete(begin(), N);
  }

  goodarray()
  {
    placement_new_default(begin(), N); // вызов конструктора без параметров
  }

  template<class V>
  goodarray(const V& v)
  {
    placement_new_fill(begin(), N, v); // вызов конструктора с 1 параметром - с одинаковым значением
  }

  template<class V>
  goodarray(const V* v, size_t M = N)
  {
    const size_t nm = min(N,M);
    placement_new_copy(begin(), nm, v); // поэлементное соответствие значений
    placement_new_default(begin()+nm, N-nm); // хвост тоже надо инициализировать
  }

  template<class V, size_t M>
  goodarray(const goodarray<V,M>& v)
  {
    const size_t nm = min(N,M);
    placement_new_copy(begin(), nm, v.begin());
    placement_new_default(begin() + nm, N-nm);
  }

  goodarray(const goodarray<T,N>& v)
  {
    placement_new_copy(begin(), N, v.begin());
  }
};

S>    int aaa[3]={1,2,3};
S>

S>А если атрибут

class test_t {
  boost::array<int, 3> aaa;
  static const boost::array<int, 3> initial_values;
  test_t() : aaa(initial_values) {}
};

const boost::array<int, 3> test_t::initial_values = {{1, 2, 3}};