1. Lagunas de memoria

return *(new prueba(p1.a + p2.a, p1.b + p2.b) );

Fíjate que estás reservando memoria dinámica con el new. En esta reserva pones un objeto que almacena el resultado de sumar p1 y p2. Después haces una copia de dicho objeto y retornas dicha copia... pero no has liberado la memoria que has reservado, por lo que estás creando lagunas de memoria.

Si en un método devuelves un objeto por valor, ese método no debe hacer uso de un "new" para almacenar el objeto que vas a retornar porque entonces tendrás problemas con la memoria. Dicho con pocas palabras, el "new" sobra:

return prueba(p1.a + p2.a, p1.b + p2.b);

2. Retorno de referencias

prueba& operator +( const prueba &p1, const prueba &p2) 
{
  return prueba(p1.a + p2.a, p1.b + p2.b); 
}

Partimos del operador una vez aplicada la corrección anterior porque no tiene sentido ir dejando lagunas de memoria. El problema ahora es que el objeto "prueba" que estamos creando dentro del operador se elimina automáticamente cuando la ejecución abandona el método. Resulta que estamos devolviendo una referencia, luego estaremos devolviendo una referencia a un objeto que no existe. El compilador seguramente te avise de esta circunstancia con, al menos, un warning.

Este método no puede devolver una referencia.

prueba operator +( const prueba &p1, const prueba &p2) 
{
  return prueba(p1.a + p2.a, p1.b + p2.b); 
}

3. Nombres de variables

prueba operator+( const prueba &p1, const prueba &p2);
prueba operator-( const prueba &p3, const prueba &p4);
prueba operator*( const prueba &p5, const prueba &p6);
prueba operator/( const prueba &p7, const prueba &p8);

La variable "p1" que usa como argumento el operador de suma únicamente va a existir dentro de dicha función. Fuera del operador suma la variable "p1" no existe, y cualquier intento por acceder a ella provocará un error al compilar. Por este motivo no hay ningún problema si repites los nombres en los diferentes métodos:

prueba operator+( const prueba &p1, const prueba &p2);
prueba operator-( const prueba &p1, const prueba &p2);
prueba operator*( const prueba &p1, const prueba &p2);
prueba operator/( const prueba &p1, const prueba &p2);

Puede parecer un cambio meramente estético, pero como pretendas escribir un programa completo sin repetir el nombre de ninguna variable, incluso si el nombre únicamente se usa en un ámbito muy reducido, puedes acabar con un dolor de cabeza muy serio.

4. Uso de los operadores

Ya has definido los operadores... ahora solo te queda usarlos. Crea varios elementos con diferentes valores y haz uso de los diferentes operadores. Después saca por pantalla los resultados y verifica que el resultado obtenido coincide con el esperado:

int main( )
{
  prueba p1( 10, 20 );
  prueba p2( 4.67, 2.44 );
 
  prueba resultado = p1 + p2;
 
  std::cout << "a=" << resultado.a << std::endl;
  std::cout << "b=" << resultado.b << std::endl;
}