struct A
{
    char field_a;

    A(): field_a('a') {}
};

struct B
{
    double c;

    B() : c(10.0) {}
};

struct D
{
    int buffer[100];

    D()
    {
      //... some code...
    }
};

boost::static_unsigned_max<sizeof(A),boost::static_unsigned_max<sizeof(B),sizeof(D)>::value >::value;

template <typename T>
const constexpr size_t MaxSize() {
  return sizeof(T);
}

template <typename u, typename v, typename... sz>
const constexpr size_t MaxSize() {
  return sizeof(u) > sizeof(v) ? MaxSize<u, sz...>() : MaxSize<v, sz...>();  
}

MaxSize<A, B, D>()

char CommonBuffer[MaxSize<A, B, D>()];

typedef vector<int,long,char,char[50],double> types;
typedef max_element
<
    transform_view< types, sizeof_<_> >
>::type iter;

BOOST_MPL_ASSERT_RELATION( deref<iter>::type::value, ==, 50 );

#include <iostream>
#include <algorithm>
#include <initializer_list>
 
using namespace std;
 
struct A
{
    char field_a;
 
    A(): field_a('a') {}
};
 
struct B
{
    double c;
 
    B() : c(10.0) {}
};
 
struct D
{
    int buffer[100];
 
    D()
    {
    }
};
 
template <typename... Types>
constexpr auto get_sizes() 
{
    return initializer_list<size_t>{ sizeof(Types)... };
}
 
int main()
{
    cout << max( get_sizes<A, B, D>() ) << endl; 
}

GC>struct A
GC>{
GC>    char field_a;

GC>    A(): field_a('a') {}
GC>};

GC>struct B
GC>{
GC>    double c;

GC>    B() : c(10.0) {}
GC>};

GC>struct D
GC>{
GC>    int buffer[100];

GC>    D()
GC>    {
GC>      //... some code...
GC>    }
GC>};
GC>

union E { char a[sizeof(A)], b[sizeof(B)], d[sizeof(D)]; };
...
char buf[sizeof(E)];

#define max(a,b) ((a)>(b)?(a):(b))

const int ms = max(max(sizeof(A), sizeof(B)), sizeof(C));

union E
{ 
  char a[sizeof(A)], 
  b[sizeof(B)], 
  d[sizeof(D)]; 

  tblib::Align<A> aa;
  tblib::Align<B> ab;
  tblib::Align<D> ad;
};

#pragma once
#include "stdint.h"
namespace tblib 
{
    template <typename T>
    struct _CheckAlign
    {
        uint8_t c;
        T t;
        _CheckAlign();
        _CheckAlign(const _CheckAlign&);
        _CheckAlign&operator=(const _CheckAlign&);
    };

    template <typename T>
    struct _AlignValue
    {
        enum { value = sizeof(_CheckAlign<T>)-sizeof(T) };
    };

    template <int N>
    struct _AlignBySize;

    template <> 
    struct _AlignBySize<1> { uint8_t  guts; };

    template <> 
    struct _AlignBySize<2> { uint16_t guts; };

    template <> 
    struct _AlignBySize<4> { uint32_t guts; };

    template <> 
    struct _AlignBySize<8> { uint64_t guts; };

    template <typename T>
    struct Align
    {
        _AlignBySize<_AlignValue<T>::value> guts;
    };
};

#include <stdio.h>
using namespace std;

struct A
{
    int a;
};

struct B
{
    char b[9];
};

union U
{
    char a[sizeof(A)];
    char b[sizeof(B)];
};

int main() {
    U u[2];
    printf("%p, %p", &(((A*)(&u[0].a))->a), &(((A*)(&u[1].a))->a) );
    return 0;
}