Considere la siguiente clase:

class A {

char *p;
int a, b, c, d;

public:
   A(const &A);
};

Tenga en cuenta que tengo que definir un constructor de copia para hacer una copia profunda de "p". Esto tiene dos problemas:

La mayoría de los campos simplemente deben copiarse. Copiarlos uno por uno es feo y propenso a errores.

Más importante aún, cada vez que se agrega un nuevo atributo a la clase, el constructor de copia debe actualizarse, lo que crea una pesadilla de mantenimiento.

Personalmente me gustaría hacer algo como:

A(const A &a) : A(a)
{
   // do deep copy of p
   :::
}

Entonces, el constructor de copia predeterminado se llama primero y luego se realiza la copia profunda.
Lamentablemente, esto no parece funcionar.

¿Hay alguna forma mejor de hacer esto? Una restricción: no puedo usar punteros compartidos / inteligentes.

Las sugerencias de Sbi tienen mucho sentido. Creo que seguiré creando clases de contenedor para manejar el recurso. No quiero usar shared_ptr ya que las bibliotecas de impulso pueden no estar disponibles en todas las plataformas (al menos no en distribuciones estándar, OpenSolaris es un ejemplo).

Todavía creo que hubiera sido genial si de alguna manera pudieras hacer que el compilador creara los operadores de construcción / asignación predeterminados para ti y simplemente pudieras agregar tu funcionalidad encima. El creador de copias creado manualmente / las funciones del operador de asignación creo que serán una molestia para crear y una pesadilla para mantener. Por lo tanto, mi regla general personal sería evitar los constructores de copia personalizados / operadores de asignación a toda costa.

Gracias a todos por sus respuestas e información útil y perdón por los errores tipográficos en mi pregunta. Lo estaba escribiendo desde mi teléfono.