const char* cadenaA = "HOLA";
char* cadenaB = new char[5];
strncpy(cadenaB, cadenaA, 5);
 
Persona personaA = new Persona();
Persona personaB = new Persona();
 
personaA.IngresarNombre(cadenaA);
 
personaB.IngresarNombre(cadenaB);
 
delete[] cadenaB;
 

Persona *personaA = new Persona();
Persona *personaB = new Persona();
// ...
delete personaA;
delete personaB; 

Persona personaA; // ya llama al constructor sin parametros sin especificarlo nosotros
// ...
// no es necesario liberar memoria ya que no se ha reservado memoria dinamicamente 

void Persona::IngresarNombre(const char *nombre);
 
void Persona::IngresarNombre(const char nombre[]); 

int main(){
    char *p_dinamico;
    p_dinamico = new char [20]; // tendras que liberarlo antes de acabar la ejecucion del programa
    char p_estatico[20]; // se liberara solo al acabar
 
    Persona my_person;
    my_person.InsertarNombre(p_dinamico); // p_dinamico lo puedes liberar en el main mas adelante
    my_person.InsertarNombre(p_estatico); // p_estatico se liberara solo
 
    delete [] p_dinamico; // como hemos dicho antes
} 

class MiClase{
    private:
        // miembros y metodos privados
    public:
        // miembros y metodos publicos
        // Opcion 1: sobrecarga con friend
        friend std::ostream& operator<<(ostream&, const MiClase&);
};
// Opcion 2: sobrecarga sin friend
std::ostream& operator<<(ostream&, const MiClase&); 

int* sumar(int a, int b){
    int *suma = new int(a+b); // reservas memoria para un entero
    return suma;
}
 
int main(){
    int *psuma = sumar(2,2); // psuma apunta a la misma memoria que apuntaba suma
    delete psuma; // liberamos la memoria a la que apunta psuma que es la misma que suma
} 

//En este fragmento al terminar la función, se destruye el contenido de suma y retorna null o vacío, y el puntero suma sigue existiendo en memoria....
int RetornaUnaSuma(int a, int b){
     int * suma = new int;
     *suma = a+b;
     return *suma;
}
//Aqui intento retornar un puntero creado dentro de la misma función...
int * RetornaUnaSuma(int a, int b){
     int * suma = new int;
     *suma = a+b;
     return suma;
     //pero al terminar la función, se destruye el contenido y retorna una dirección de memoria sin contenido, el puntero sigue existiendo..
}
 

//Segun yo esto debe funcionar...
int * RetornaUnaSuma(int * pSuma, int a, int b){
     *pSuma = a+b;
     return pSuma;
}
 

• Variante 1
  La más simple, una función que suma los parámetros en un entero y lo retorna.
  
  Código

  int sumar(int a, int b){
      int suma = a + b;
      return suma;
  } 

  En este caso no hay mucha complicación, la variable <suma> que es de ámbito local se destruye al terminar la función.
  
  
• Variante 2
  Usando punteros. Creamos un puntero a entero donde se va a guardar la suma y retornamos el puntero .
  
  Código

  int* sumar(int a, int b){
      int *psuma = new int (a + b);
      return psuma;
  } 

  En este caso como estamos usando memoria dinámica al usar <new>, tenemos que liberar luego la memoria con <delete>. Como la función retorna el puntero no hay problema porque esa función se tiene que asignar a un puntero a entero en otro sitio (ya sea en el <main> o en otra función). Entonces liberamos la memoria en ese sitio:
  
  Código

  int main(){
      int *psuma = sumar(2,2);
      // usas el puntero psuma
      delete psuma;
  } 

  
  
• Variante 3
  Esto es lo que has implementado en primer lugar y la opción más rara y menos apropiada. Crear un putero a entero donde guardar la suma y retornar el valor de la suma .
  
  Código

  int sumar(int a, int b){
      int *psuma = new int (a + b);
      return *psuma;
  } 

  En este caso tenemos un problema con la memoria dinámica. Una de las cosas que tiene la memoria dinámica es que cuando se crea un objeto/variable usando esta, el objeto/variable siempre debe estar apuntado por algún puntero. Si deja de ser apuntado por alguien, se pierde. Entonces aquí cuando acaba la función retorna el valor de la suma, el cual es correcto, pero se pierde el puntero <psuma> por lo que ya no se puede liberar.
  
  Código

  int main(){
      int suma = sumar(2,2);
      // usamos la variable suma pero...
      // hemos perdido el puntero local de la funcion
  } 

  ---

  Si quieres profundizar un poco el tema de los valores de retorno, que se guarde temporalmente el valor que se devuelve antes de ser destruido puedes indagar un poco dentro del lenguaje ensamblador. Puedes ver una llamada a función sencilla como esta para ver como la función guarda en un registro el valor de retorno. Entonces cuando la función ha acabado, el valor de retorno está guardado en un registro que debe ser guardado en otro sitio antes de volver a usar ese registro, por eso hay que asignarlo a una variable. Suerte