¿Es un constructor público en una clase abstracta un olor a código?

Lo he leído en al menos una pauta de codificación que los constructores de clases abstractas no deben ser públicos. Creo que esa regla tiene sentido por la razón que diste.

Sin embargo, no puedo imaginar un escenario en el que hacerlo público haga que las cosas salgan mal. Así que no iría tan lejos como para decir que es un olor a código. Veo el constructor protegido como una propiedad "agradable de tener" :)

Mi opinión sería que el constructor público podría parecer confuso y, como usted dice, sería correcto protegerlo. Diría que un constructor protegido refuerza correctamente la impresión de que el único uso sensato de una clase abstracta es derivar de ella.

De hecho, solo necesita declarar un constructor en una clase abstracta si necesita hacer algo, por ejemplo. inicializar sus propios miembros privados. Entonces esperaría que hubiera otras funciones miembro protegidas que sean útiles para las clases derivadas.

EDITAR:

Dado que nadie ha publicado ningún código y @sbi pidió algunos en un comentario a OP, pensé en publicar algunos:

class Base:
{
public:           // The question is: should the ctor be public or protected?
// protected:
    Base():i(0){} // ctor is necessary to initialise private member variable
public:
    virtual ~Base(){} // dtor is virtual (but thats another story)
                  // pure virtual method renders the whole class abstract
    virtual void setValue(void)=0;  
protected:
    int getValue(void){ return i;}
private:
    int i;
};

Base b1;  // Illegal since Base is abstract, even if ctor is public
Base& b2=makeBase();  //We can point to, or refer to a Base
b2.setValue();    // We're not sure what this does, but we can call it.
b2.getValue();    // Illegal since getValue is protected

Como usted dice, no es necesario proporcionar un constructor público de clase abstracta, ni puede ser mal utilizado si proporciona un constructor público.

Sin embargo, puede considerar declarar el constructor como público como recomendación para estructurar clases derivadas del abstracto.