It looks like you have two motivations here:

1. Remove repetition of passing the owning GameObject* around.

2. Ensure that Components can add other components to their owning GameObject inside the Component constructor.

1 - Passing GameObject*s:

I wouldn't worry about having to pass the owning GameObject* around. Assuming our base Component class looks something like this:

class Component
{
private:

    GameObject* owner;

public:

    virtual ~Component() { }
    
    GameObject* get_owner() const { return owner; }

protected:

    explicit Component(GameObject* owner):
        owner(owner) { }

};

All our component classes will take the owner pointer in a constructor and pass it to their base Component:

explicit CheckNameComponent(GameObject* owner):
    Component(owner) { ... }

Where the GameObject pointer is passed as the first argument in GameObject::add_component:

std::make_unique<ComponentT>(this, std::forward<Args>(args)...);

The only repeated "boilerplate" code here is the two lines in every component:

explicit CheckNameComponent(GameObject* owner):
    Component(owner) { ... }

This is completely fine. It's not something that needs to be replaced with a very complicated system of construction using placement new and inheritance.

2 - Adding Components from Component constructors:

I think the problem here is with add_component being called recursively, e.g.:

CheckNameComponent()
{
    std::cout << "CheckNameComponent is created" << std::endl;

    if (begin->owner->name == "Game object")
        begin->owner->add_component<GameObjectComponent>();
}

We need to be careful with ordering things so that:

• We return the correct pointer from add_component.

• Reallocation from recursive calls doesn't move our objects in memory (which I guess is why std::list is used instead of std::vector).

• Certain rules are enforced with the order of construction of "child" components. (i.e. can a component added by an add_component call in a component constructor check that it's "parent" component exists on the owning game object? so could GameObjectComponent do begin->owner->get_component<CheckNameComponent>?)

That last one is kinda hard to solve. It's up to you what exactly you want to do in this situation. Since the CheckNameComponent constructor hasn't returned, we can't guarantee that the object is "safe" to use in GameObjectComponent. But we could perhaps try to guarantee that GameObjectComponent can get a pointer to CheckNameComponent.

Personally I wouldn't try to make this guarantee! I think it's fine to document that components are not there in the GameObject (and can't be accessed) until add_component returns successfully.

Then we can use a std::vector<std::unique_ptr<Component>> for the components, and create the component before we add space for it in the component list:

template<class ComponentT, class... Args>
ComponentT* add_component(Args&&... args)
{
    auto component = std::make_unique<ComponentT>(this, std::forward<Args>(args)...);
    auto result = component.get();
    components.push_back(std::move(component));
    return result;
}

If a "child" component needs to be added, and needs access to its parent, it's up to the writer of the Component class to explicitly pass the relevant dependencies, e.g.:

explicit CheckNameComponent(GameObject* owner):
    Component(owner)
{
    if (get_owner()->name == "Game object")
        get_owner()->add_component<OtherComponent>(this); // pass the needed pointer
}

explicit OtherComponent(GameObject* owner, CheckNameComponent* check_name):
    Component(owner)
{
    // use `check_name` here... it's up to the programmer to ensure we only access valid state
}

So overall I'm not sure the added complexity is worth it. I think the same thing can be achieved like so:

#include <iostream>
#include <memory>
#include <vector>

class Component;

class GameObject
{
public:

    explicit GameObject(std::string const& name):
        name(name) { }

    template<class ComponentT, class... Args>
    ComponentT* add_component(Args&&... args)
    {
        auto component = std::make_unique<ComponentT>(this, std::forward<Args>(args)...);
        auto result = component.get();
        components.push_back(std::move(component));
        return result;
    }

    std::string name;

private:

    std::vector<std::unique_ptr<Component>> components;
};

class Component
{
private:

    GameObject* owner;

public:

    virtual ~Component() { }

    GameObject* get_owner() const { return owner; }

protected:

    explicit Component(GameObject* owner):
        owner(owner) { }

};

class OtherComponent;

class CheckNameComponent : public Component
{
public:

    explicit CheckNameComponent(GameObject* owner):
        Component(owner)
    {
        if (get_owner()->name == "Game object")
        {
            get_owner()->add_component<OtherComponent>();
        }
    }
};

class OtherComponent : public Component
{
public:

    explicit OtherComponent(GameObject* owner):
        Component(owner)
    {
        std::cout << "OtherComponent constructor\n";
    }

    ~OtherComponent()
    {
        std::cout << "OtherComponent destructor\n";
    }
};

int main()
{
    {
        auto object = GameObject("Game object");
        object.add_component<CheckNameComponent>();
    }

    std::cout << std::flush;
}

Some other things:

(Although I've suggested removing / changing most of your code above, here are some comments about your code as it exists at the moment).

Naming:

Initialize is not a good name for a class. Classes should usually use nouns for names, not verbs. Something like ComponentOwner or just ComponentBase might be better.

The name begin is nearly always used in C++ for something specific (the first iterator in a sequence), so it shouldn't be used for something else. This variable should probably be named after the Initialize class (so owner or base if you use my suggestions above).

malloc:

In C++ we should use the global operator new to allocate memory, instead of malloc. (And of course use delete instead of free).