#include <vector>

struct Foo
{
    Foo() {}

    void load(/*...*/)
    {
        v.clear(); // тут возникает assert "итераторы несовместимы"
    }

    std::vector<int> v;
};

struct Bar
{
    Bar(Foo& f)
    {
        //...
        f.load(/*...*/);
    }
};

struct Holder
{
    Holder()
        : bar(foo)
        , foo()
    {}

    Bar bar;
    Foo foo;
};

int main()
{
    Holder h;
}

struct Holder
{
    Holder()
        : foo() 
          bar(foo)
    {}

    Foo foo;
    Bar bar;
};

IRO>>Чтото мне подсказывает что такая работа запрещена стандартом, хотя могу ошибаться

Before the lifetime of an object has started but after the storage which the object will occupy has been allocated34)
or, after the lifetime of an object has ended and before the storage which the object occupied is
reused or released, any pointer that refers to the storage location where the object will be or was located
may be used but only in limited ways. Such a pointer refers to allocated storage (3.7.3.2), and using the
pointer as if the pointer were of type void*, is welldefined.
Such a pointer may be dereferenced but the
resulting lvalue may only be used in limited ways, as described below. If the object will be or was of a
class type with a nontrivial
destructor, and the pointer is used as the operand of a deleteexpression,
the
program has undefined behavior. If the object will be or was of a nonPOD
class type, the program has
undefined behavior if:
— the pointer is used to access a nonstatic data member or call a nonstatic member function of the object, or
— the pointer is implicitly converted (4.10) to a pointer to a base class type, or
— the pointer is used as the operand of a static_cast (5.2.9) (except when the conversion is to
void*, or to void* and subsequently to char*, or unsigned char*).
— the pointer is used as the operand of a dynamic_cast (5.2.7).

-Wextra -Wall -ansi -pedantic -Weffc++

IRO>>Ну я именно это и хотел сказать, что дело не в порядке, а вообще в том что мы используем(разыменовываем) неготовый указатель.

struct Bar
{
    Bar(Foo & f)
    {
        //...
        f.load(); //а это что?
    }
};

W>struct Bar
W>{
W>    Bar(Foo & f)
W>    {
W>        //...
W>        f.load(); //а это что?
W>    }
W>};
W>

    Holder()
        : bar(foo) //а это что???

W>struct Bar
W>{
W>    Bar(Foo & f)
W>    {
W>        //...
W>        f.load(); //а это что?
W>    }
W>};
W>

void load(/*...*/)
    {
        v.clear(); // оно в дебрях там
    }

struct HolderBase 
{
   Foo foo;
};

struct Holder : protected HolderBase
{
    Holder()
        : bar(foo)
    {}

    Bar bar;
};