Ahmed AEK's questions

normalmente encontro esse trecho aparecendo em meu código, onde dois objetos que não possuem um ao outro precisam ter um ponteiro um para o outro, e esse ponteiro deve ser "limpo" quando um deles for destruído da seguinte maneira.

struct bar;
struct foo;

struct foo
{
    bar* bar_item = nullptr;
    ~foo();
};

struct bar
{
    foo* foo_item = nullptr;
    ~bar()
    {
        if (foo_item)
        {
            foo_item->bar_item = nullptr;
        }
    }
};

foo::~foo()
{
    if (bar_item)
    {
        bar_item->foo_item = nullptr;
    }
}

int main()
{
    foo obj1;
    bar obj2;
    obj1.bar_item = &obj2;
    obj2.foo_item = &obj1;
}

o problema aqui é que eu também tenho que

1. exclua o construtor/atribuição de cópia e implemente o construtor/atribuição de movimento (muito clichê, espere pelo menos 5 membros por classe)
2. converta todos os objetos em shared_ptr e os objetos terão fraco_ptr entre si. (talvez nem sempre seja viável, pois posso não possuir a vida útil dos objetos, também me obriga a usar o heap)

existe alguma maneira de evitar isso? simplificá-lo? tem um wrapper RAII para um membro específico para evitar a implementação das operações de copiar/mover?

um exemplo simples que encontrei uma vez é um sistema gráfico onde preciso de uma linha para conectar duas esferas, a linha deve ter ponteiros para ambas as esferas e as esferas devem ter um ponteiro para a linha, todas elas pertencem à "cena" , mas perguntar a "cena" sobre eles requer uma longa pesquisa, os ponteiros evitam essa pesquisa.

Eu tenho um caso em que quero que o parâmetro de função padrão mude quando o tipo de entrada especificou certas características, por exemplo, um objeto pmr tem uma característica de alocador e uma get_allocatorfunção, então como faço isso? Eu apreciaria uma solução c++ 20 que não envolva SFINAE, a menos que seja impossível, talvez usando if constexpr ou conceitos, não quero escrever duas funções, a menos que seja impossível.

template<typename T>
void new_deleter(T* ptr)
{
    delete ptr;
}

template <typename T>
void pmr_deleter(T* ptr)
{
    ptr->get_allocator().delete_object(ptr);
}

template<typename T>
using deleter_t = void (*)(T*);

// use pmr_deleter by default when possible
template<typename T>
void delete_object(T* ptr, deleter_t<T> deleter = &new_deleter<T>)
{
    deleter(ptr);
}

Editar: graças à resposta descobri o seguinte padrão, que poderia ser facilmente adaptado aos conceitos e ao contexto.

template<typename T>
deleter_t get_default_deleter() {return &new_deleter<T>;}

template<typename T>
deleter_t get_default_deleter() 
requires requires (T* ptr) {ptr->get_allocator();}
{
 return &pmr_deleter<T>;
}

template<typename T>
void delete_object(T* ptr, deleter_t<T> deleter = get_default_deleter<T>())
{
    deleter(ptr);
}