gcc странно инициализирует std::vector внутри структурки

 #include <iostream>                                                                                                                
 #include <vector>                                                                                                                  
                                                                                                                                    
 struct A                                                                                                                           
 {                                                                                                                                  
     int a;                                                                                                                         
     std::vector<int> v;                                                                                                            
 };                                                                                                                                 
                                                                                                                                    
 struct B                                                                                                                           
 {                                                                                                                                  
     B()                                                                                                                            
 #ifdef WITH_INIT                                                                                                                   
     : a()                                                                                                                          
 #endif                                                                                                                             
     {                                                                                                                              
         std::cout << a.a << std::endl;                                                                                             
     }                                                                                                                              
                                                                                                                                    
     A a;                                                                                                                           
 };                                                                                                                                 
                                                                                                                                    
 int main()                                                                                                                         
 {                                                                                                                                  
     B b;                                                                                                                           
     b.a.v.push_back(42);                                                                                                           
 }                                                                                                                                  

Value     Name           Description 
------   --------        -------------------------
0xCD     Clean Memory    Allocated memory via malloc or new but never 
                         written by the application. 

0xDD     Dead Memory     Memory that has been released with delete or free. 
                         Used to detect writing through dangling pointers. 

0xED or  Aligned Fence   'No man's land' for aligned allocations. Using a 
0xBD                     different value here than 0xFD allows the runtime
                         to detect not only writing outside the allocation,
                         but to also detect mixing alignment-specific
                         allocation/deallocation routines with the regular
                         ones.

0xFD     Fence Memory    Also known as "no mans land." This is used to wrap 
                         the allocated memory (surrounding it with a fence) 
                         and is used to detect indexing arrays out of 
                         bounds or other accesses (especially writes) past
                         the end (or start) of an allocated block.

0xFD or  Buffer slack    Used to fill slack space in some memory buffers 
0xFE                     (unused parts of `std::string` or the user buffer 
                         passed to `fread()`). 0xFD is used in VS 2005 (maybe 
                         some prior versions, too), 0xFE is used in VS 2008 
                         and later.

0xCC                     When the code is compiled with the /GZ option,
                         uninitialized variables are automatically assigned 
                         to this value (at byte level). 


// the following magic values are done by the OS, not the C runtime:

0xAB  (Allocated Block?) Memory allocated by LocalAlloc(). 

0xBAADF00D Bad Food      Memory allocated by LocalAlloc() with LMEM_FIXED,but 
                         not yet written to. 

0xFEEEFEEE               OS fill heap memory, which was marked for usage, 
                         but wasn't allocated by HeapAlloc() or LocalAlloc(). 
                         Or that memory just has been freed by HeapFree().