Editar. Na verdade, enquanto o que digo na minha primeira resposta é válido, esse é o verdadeiro motivo .:
No início, havia C. C não é orientado a objetos (você pode adotar uma abordagem OO, mas não ajuda ou aplica nada).
Havia C With Classes, que mais tarde foi renomeado para C ++. O C ++ é orientado a objetos e, portanto, incentiva o encapsulamento e garante a invariância de um objeto - na construção e no início e no final de qualquer método, o objeto está em um estado válido.
A coisa natural a fazer com isso é impor que uma classe sempre tenha um construtor para garantir que ele inicie em um estado válido - se o construtor não precisar fazer nada para garantir isso, o construtor vazio documentará esse fato .
Mas um objetivo com C ++ era ser compatível com C, a ponto de, na medida do possível, todos os programas C válidos também serem programas C ++ válidos (não é mais um objetivo ativo, e a evolução de C separada para C ++ significa que ele não é mais válido). )
Um efeito disso foi a duplicação na funcionalidade entre struct
e class
. O primeiro fazendo as coisas da maneira C (tudo público por padrão) e o segundo fazendo as coisas de uma maneira OO (tudo privado por padrão, o desenvolvedor torna público o que quer que seja público).
Outra é que, para um C struct
, que não poderia ter um construtor porque C não possui construtores, para ser válido em C ++, era necessário que houvesse um significado para isso na maneira como o C ++ olhava. E assim, embora não ter um construtor fosse contra a prática OO de garantir ativamente um invariável, o C ++ entendeu que isso significava que havia um construtor sem parâmetros padrão que agia como se tivesse um corpo vazio.
Todos os C structs
agora eram C ++ válidos structs
(o que significava que eram iguais a C ++ classes
com tudo - membros e herança - público) tratados externamente como se tivesse um construtor único e sem parâmetros.
Se, no entanto, você colocou um construtor em a class
ou struct
, então estava fazendo as coisas da maneira C ++ / OO em vez da maneira C, e não havia necessidade de um construtor padrão.
Como funcionava como um atalho, as pessoas continuavam usando-o mesmo quando a compatibilidade não era possível de outra maneira (ele usava outros recursos do C ++ que não estavam em C).
Portanto, quando o Java surgiu (baseado em C ++ de várias maneiras) e depois em C # (baseado em C ++ e Java de maneiras diferentes), eles mantiveram essa abordagem como algo que os codificadores já podem estar acostumados.
Stroustrup escreve sobre isso em sua linguagem de programação The C ++ e, mais ainda, com mais foco nos "porquês" da linguagem em The Design and Evolution of C ++ .
=== Resposta original ===
Digamos que isso não aconteceu.
Digamos que eu não queira um construtor sem parâmetros, porque não posso colocar minha classe em um estado significativo sem um. Na verdade, isso é algo que pode acontecer com o struct
C # (mas se você não pode fazer uso significativo de todos os zeros e nulos struct
no C #, na melhor das hipóteses, você usa uma otimização não visível ao público e, caso contrário, possui uma falha de design no uso struct
).
Para tornar minha classe capaz de proteger seus invariantes, preciso de uma removeDefaultConstructor
palavra-chave especial . No mínimo, eu precisaria criar um construtor privado sem parâmetros para garantir que nenhum código de chamada chame o padrão.
O que complica ainda mais a linguagem. Melhor não fazer isso.
Em suma, é melhor não pensar em adicionar um construtor como removendo o padrão, melhor pensar em não ter nenhum construtor como açúcar sintático para adicionar um construtor sem parâmetros que não faz nada.