Outro dia vi o código que usa o chamado padrão singleton. Significado algo ao longo das linhas de

class MySingleton{
public:
    void foo() { ... }
    static MySingleton&get_instance(){
        static MySingleton singleton;
        return singleton
    }
private:
    MySingleton(){ ... }
    ~MySingleton(){ ... }
    int bar;
};

Eu vejo por que alguém iria querer fazer isso:

Torne a instância globalmente acessível.Certifique-se de que nunca haja mais de uma instância dessa classe.

No entanto, não vejo por que esse modo de fazer as coisas é superior a algumas funções livres. A maneira que eu implementaria é colocar

namespace some_name{
    void foo();
}

no cabeçalho e

namespace some_name{
    void foo(){
        ...
    }
}

no arquivo de implementação. Se eu precisar de inicialização e / ou limpeza, eu adiciono algumas funções que devem ser explicitamente chamadas ou eu adiciono

namespace{
    class Dummy{
        Dummy(){ ... }
        ~Dummy(){ ... }
    }dummy;
}

no arquivo de implementação.

Eu sei que isso é de um ponto de vista semântico um singleton, no entanto, vejo a primeira variante usada com mais freqüência no código C ++ do que o segundo. Por quê? Eu considero a segunda versão um pouco superior, então me pergunto se estou perdendo algo óbvio.

A segunda versão é mais simples de implementar e menos propensa a erros. Na primeira variante, o construtor de cópia privada está ausente de propósito para demonstrar isso. Na segunda variante, não há como fazer esse erro.Implementação e interface são melhor separadas na segunda versão. No primeiro, todos os membros privados devem ser declarados no cabeçalho. Isso tem a vantagem de poder reescrever a implementação do zero e nem mesmo precisar recompilar qualquer coisa que use o singleton. Ao usar a primeira variante, é muito provável que você tenha que recompilar todo o código do usuário, mesmo quando apenas alterar pequenos detalhes de implementação.Os detalhes da implementação estão ocultos nos dois casos. Na primeira variante usando private e na segunda variante usando namespaces sem nome.

Você pode me explicar por que todo mundo usa a primeira variante? Eu não vejo uma única vantagem sobre o bom e velho jeito de fazer as coisas em C.