Newline's questions

Tenho uma construção semelhante ao CRTP:

class Derived : public Base<Derived>

Preciso calcular um ponteiro para um Derivedobjeto a partir de um ponteiro para Base<Derived>objeto via reinterpret_cast. Não posso usar dynamic_castporque não estou usando funções virtuais aqui.

Os tipos são fornecidos, eu tenho o ponteiro para o Base<Derived>objeto. Preciso do deslocamento de bytes entre os dois tipos, para poder usar reinterpret_cast. Como faço isso (sem comportamento indefinido)? É possível fazer em tempo de compilação / salvar como uma static constexprvariável (estou usando C++20)?

Li que para fazer o contêiner personalizado funcionar com o loop for baseado em intervalo, "coisas" precisam estar no mesmo namespace. Quais coisas precisam estar no mesmo namespace? As funções livres begin-end e o iterador que ele retorna? Ou as funções begin-end e o contêiner passado a elas?

Estou trabalhando em um motor de jogo básico, seguindo o conselho de incluir apenas o que preciso. Estou percebendo que em alguns lugares estou incluindo toneladas de coisas de certos módulos, como Math ou Render. E então é suposto manter essas longas listas regularmente para que seja realmente apenas o que se precisa, nem menos nem mais.

Mas é realmente tão importante incluir coisas que não preciso? Não posso simplesmente incluir Render.hpp e Math.hpp onde uso coisas de render e math e pronto, em vez de caçar todos os cabeçalhos para cada pequeno componente separadamente e manter uma longa lista de inclusões? O conselho profissional é sempre incluir apenas o que preciso, mas a maioria das bibliotecas que uso são incluídas por um include ou separadamente seus módulos principais, mas não todos os seus cabeçalhos um por um.

Incluir mais do que preciso realmente cria tanta bagunça e aumenta tanto o tempo de compilação/análise?

struct Fooo
{
    void func() const {}

protected:
    void func() {}
};

...

Fooo fooo;
fooo.func();

O compilador diz que func é inacessível, porque é protegido. Por que funciona assim? Eu esperava que a versão não-const simplesmente não fosse vista e a const fosse chamada.

Eu encontrei isso com uma classe dando acesso const ao membro enquanto também tinha a versão não const da função para uso interno. O outro caso ao fazer uma classe base "protected mutable" com todos os acessadores não const declarados protected, então uma classe poderia derivar dela e manter seus dados não mutáveis ​​pelo público e outra classe derivada tornou os getters disponíveis ao trazer para o escopo público, como Base::getterFunc;.

class Base
{
    int a;

public:
    const auto& getA() const { return a; }

protected:
    auto& getA() { return a; }
};

class PublicAccess : public Base
{
public:
    Base::getA;
};

class KeepProtected : public Base
{

};

Um caso específico foi Vectore NormalizedVectorderivado de VectorBase. NormalizedVectorpode mutar seus elementos não aleatoriamente pelo público.

Em qualquer caso, os exemplos não são o ponto, apenas me pergunto qual é a lógica por trás dessa inacessibilidade, quando a versão protegida poderia ser simplesmente vista como inexistente e a versão const poderia ser escolhida.

struct Foo
{
    struct Bar
    {
        int data = 0;

        //constexpr Bar() = default; // Doesn't work either
        constexpr Bar() : data(0) {}
    };

    static constexpr Bar bar = {}; // ERROR
    //static constexpr Bar bar = {0}; // Works if the ctor from Bar is removed
};

Clang e GCC (com std=c++20) dizem que o construtor que estou tentando usar é indefinido. Mas funciona se eu mudar constexprpara inline. Gostaria de entender o que há de errado em usar 'contexpr'.