As I was building a project recently, I noticed that I got a compiler warning (turned to error) about the `BOOST_STRONG_TYPEDEF` macro being redefined. Upon further investigation I noticed that there are two different versions of `strong_typedef.hpp` included in boost: One at the top level, and one within `serialization/`.

There is actually a difference between the two versions as well, not just a duplicate version of the macro. The top level version doesn't explicitly value-init its `T` while the serialization version does:

Code snips:

`boost/strong_typedef.hpp`:

```
    T t;                                                        \
    explicit D(const T t_) : t(t_) {};                          \
    D(){};                                                      \
    D(const D & t_) : t(t_.t){}                                 \

```

`boost/serialization/strong_typedef.hpp`:

```
    T t;                                                        \
    explicit D(const T t_) : t(t_) {};                          \
    D(): t() {};                                                \
    D(const D & t_) : t(t_.t){}                                 \

```

Why are there two different versions of the macro, and which one makes more sense as the implementation? The one that will force builtin types to be initialized, or the one that doesn't (as closely as possible mimicing the underlying type being strongly typedeffed)?