Por que não há classe base em C ++?

Do ponto de vista do design, por que, em C ++, não existe uma classe-base mãe de todas, o que normalmente ocorre objectem outras linguagens?

A decisão definitiva pode ser encontrada nas Perguntas frequentes da Stroustrup . Em suma, não transmite nenhum significado semântico. Terá um custo. Os modelos são mais úteis para contêineres.

Por que C ++ não tem um objeto de classe universal?

• Não precisamos de um: a programação genérica fornece alternativas estaticamente seguras na maioria dos casos. Outros casos são tratados com herança múltipla.

• Não existe uma classe universal útil: um verdadeiramente universal não carrega semântica própria.

• Uma classe "universal" incentiva o pensamento desleixado sobre tipos e interfaces e leva a uma verificação excessiva do tempo de execução.

• Usar uma classe base universal implica em custo: os objetos devem ser alocados no heap para serem polimórficos; isso implica custo de memória e acesso. Objetos heap não suportam naturalmente a semântica de cópia. Objetos heap não suportam comportamento de escopo simples (o que complica o gerenciamento de recursos). Uma classe base universal incentiva o uso de dynamic_cast e outras verificações de tempo de execução.

Vamos primeiro pensar sobre por que você gostaria de ter uma classe base em primeiro lugar. Posso pensar em alguns motivos diferentes:

1. Para dar suporte a operações genéricas ou coleções que funcionarão em objetos de qualquer tipo.
2. Para incluir vários procedimentos que são comuns a todos os objetos (como gerenciamento de memória).
3. Tudo é um objeto (sem primitivos!). Algumas linguagens (como Objective-C) não têm isso, o que torna as coisas muito confusas.

Estas são as duas boas razões pelas quais as linguagens da marca Smalltalk, Ruby e Objective-C têm classes base (tecnicamente, Objective-C não tem realmente uma classe base, mas para todos os efeitos e propósitos, ela tem).

Para o nº 1, a necessidade de uma classe base que unifique todos os objetos em uma única interface é evitada pela inclusão de modelos em C ++. Por exemplo:

void somethingGeneric(Base);

Derived object;
somethingGeneric(object);

é desnecessário, quando você pode manter a integridade do tipo por meio de polimorfismo paramétrico!

template <class T>
void somethingGeneric(T);

Derived object;
somethingGeneric(object);

Para o nº 2, enquanto em Objective-C, os procedimentos de gerenciamento de memória são parte da implementação de uma classe e são herdados da classe base, o gerenciamento de memória em C ++ é executado usando composição em vez de herança. Por exemplo, você pode definir um wrapper de ponteiro inteligente que fará a contagem de referência em objetos de qualquer tipo:

template <class T>
struct refcounted
{
  refcounted(T* object) : _object(object), _count(0) {}

  T* operator->() { return _object; }
  operator T*() { return _object; }

  void retain() { ++_count; }

  void release()
  {
    if (--_count == 0) { delete _object; }
  }

  private:
    T* _object;
    int _count;
};

Então, em vez de chamar métodos no próprio objeto, você chamaria métodos em seu invólucro. Isso não apenas permite uma programação mais genérica: também permite separar interesses (uma vez que, idealmente, seu objeto deveria estar mais preocupado com o que deveria fazer, do que como sua memória deveria ser gerenciada em diferentes situações).

Por último, em uma linguagem que possui objetos primitivos e reais como C ++, os benefícios de ter uma classe base (uma interface consistente para todos os valores) são perdidos, já que você tem certos valores que não podem estar em conformidade com essa interface. Para usar primitivos nesse tipo de situação, você precisa transformá-los em objetos (se o seu compilador não fizer isso automaticamente). Isso cria muitas complicações.

Então, uma resposta curta para sua pergunta: C ++ não tem uma classe base porque, tendo polimorfismo paramétrico por meio de templates, não precisa.

O paradigma dominante para variáveis ​​C ++ é a passagem por valor, não a passagem por ref. Forçar tudo a ser derivado de uma raiz Objecttornaria a passagem deles por valor um erro ipse facto.

(Porque aceitar um objeto por valor como parâmetro, por definição iria cortá-lo e remover sua alma).

Isso não é bem-vindo. C ++ faz você pensar se você deseja valor ou semântica de referência, dando-lhe a escolha. Isso é importante na computação de desempenho.

O problema é que EXISTE esse tipo em C ++! É sim void. :-) Qualquer ponteiro pode ser lançado implicitamente com segurança void *, incluindo ponteiros para tipos básicos, classes sem tabela virtual e classes com tabela virtual.

Uma vez que deve ser compatível com todas essas categorias de objetos, voidele mesmo não pode conter métodos virtuais. Sem funções virtuais e RTTI, nenhuma informação útil sobre o tipo pode ser obtida void(ele corresponde a TODOS os tipos, então pode dizer apenas coisas que são verdadeiras para TODOS os tipos), mas as funções virtuais e RTTI tornariam os tipos simples muito ineficazes e impediriam o C ++ de ser uma linguagem adequada para programação de baixo nível com acesso direto à memória, etc.

Então, existe esse tipo. Ele apenas fornece uma interface muito minimalista (na verdade, vazia) devido à natureza de baixo nível da linguagem. :-)

C ++ é uma linguagem fortemente tipada. No entanto, é intrigante que ele não tenha um tipo de objeto universal no contexto da especialização de modelo.

Pegue, por exemplo, o padrão

template <class T> class Hook;
template <class ReturnType, class ... ArgTypes>
class Hook<ReturnType (ArgTypes...)>
{
   ...
   ReturnType operator () (ArgTypes... args) { ... }
};

que pode ser instanciado como

Hook<decltype(some_function)> ...;

Agora, vamos supor que queremos o mesmo para uma função específica. Gostar

template <auto fallback> class Hook;
template <auto fallback, class ReturnType, class ... ArgTypes>
class Hook<ReturnType fallback(ArgTypes...)>
{
   ...
   ReturnType operator () (ArgTypes... args) { ... }
};

com a instanciação especializada

Hook<some_function> ...

Mas, infelizmente, embora a classe T possa representar qualquer tipo (classe ou não) antes da especialização, não há equivalente auto fallback(estou usando essa sintaxe como o não-tipo genérico mais óbvio neste contexto) que poderia substituir qualquer argumento de modelo sem tipo antes da especialização.

Portanto, em geral, esse padrão não é transferido de argumentos de template de tipo para argumentos de template não-tipo.

Como acontece com muitos cantos na linguagem C ++, a resposta provavelmente é "nenhum membro do comitê pensou nisso".

C ++ foi inicialmente chamado de "C com classes". É uma progressão da linguagem C, ao contrário de outras coisas mais modernas como C #. E você não pode ver C ++ como uma linguagem, mas como uma base de linguagens (Sim, estou me lembrando do livro de Scott Meyers Effective C ++).

O próprio C é uma mistura de linguagens, a linguagem de programação C e seu pré-processador.

C ++ adiciona outra combinação:

• a abordagem de classe / objetos

• modelos

• o STL

Eu pessoalmente não gosto de algumas coisas que vêm diretamente de C para C ++. Um exemplo é o recurso enum. A maneira como o C # permite que o desenvolvedor o use é muito melhor: ele limita o enum em seu próprio escopo, tem uma propriedade Count e é facilmente iterável.

Como C ++ queria ser retrocompatível com C, o designer foi muito permissivo em permitir que a linguagem C entrasse em sua totalidade para C ++ (existem algumas diferenças sutis, mas não me lembro de nada que você pudesse fazer usando um compilador C que você não poderia fazer usando um compilador C ++).