Q:

Change code from using heap to using the stack

Have the following two code snippets which use the heap.  I need to change to use the stack.
  prof_pair_class* ptr_prof_pair = (new prof_pair_class(
        aa_profile
      , bb_profile
      , aa_type
      , bb_type
      ));

and
   aa_plan = new nPlan(
         aa_prof_analysis
         , prm_segment_data.aa_field.target_gqi
         , prm_segment_data.aa_field.aa_response
         , prm_segment_data.aa.user_type
         );

A:

There are four types of objects in C++ Automatic/Static/Dynamic/Thread storage duration objects.
The two I will discuss here are Automatic and Dynamic.
Dynamic Storage Duration
These objects are created via new and their lifespan ends when passed to delete (or their array equivalents).
Type*  val = new Type(<param>);  // Object created here.
                                 // Will live until delete is called on val
                                 // If you forget or there is a bug that misses the delete.
                                 // the object will be leaked.

In modern C++ it is rare to see naked new/delete as memory management is usually done via containers or smart pointers (this prevents manual memory management that is the bane of C applications).
Automatic Storage Duration
These objects are created in the current local scope (at the point of declaration) and their lifespan ends when control exits the current scope.
{
    Type  val(<param>);   // declared here
    // STUFF
}                         // end of scope here.
                          // The object's lifespan ends here and
                          // the object is automatically destroyed.

Inside Objects
Both automatic and dynamic objects can live inside class(s). For dynamic objects nothing changes, but the use of constructors and destructors help to correctly manage the lifespan of the pointer (if done correctly (see rule of five)).
But for automatic variables the scope of the variable becomes the lifespan of the object they are in. If the parent is an automatic object then when the parent leaves scope and its lifespan ends so does the children members. If the parent is dynamic then the children members scope ends when the parent is passed to delete.
class X
{
    Y  val;   // The scope of the automatic member val is X
};               // If the parent object is alive then val is alive.

{
    X  tmp;
}            // tmp goes out of scope. Then tmp is destroyed as is tmp.val

X* ptr = new X;  // the object pointed at by ptr lives until it is deleted.
                 // So its member val will live until the parent is deleted.

In your case.
TO convert your object from Dynamic to automatic simply stop using new.
// declare a dynamic variable.
prof_pair_class* ptr_prof_pair = new prof_pair_class(
        aa_profile
      , bb_profile
      , aa_type
      , bb_type
      );

{
    // declare an automatic variable.
    prof_pair_class prof_pair(
            aa_profile
          , bb_profile
          , aa_type
          , bb_type
          );
}

Passing to function:
If your original function called looked like this:
AAAAA_Facade::process_profile_dta(prof_pair_class,
                                  &fg_prof_analysis,
                                  &gf_prof_analysis
                                 );

Then you will need to change the call to look like this.
AAAAA_Facade::process_profile_dta(&prof_pair,        // Add the & here.
                                  &fg_prof_analysis,
                                  &gf_prof_analysis
                                 );

The reason is that the function is expecting a pointer to prof_pair_class. SO the expected type is prof_pair_class*. The type of the automatic variable is prof_pair_class so we need to convert the object into a pointer by using the address operator &.
Note: There is a danger to doing this. If the function is expecting a dynamically allocated object and you pass the address of an automatic object then things can go seriously wrong when the function calls delete on your pointer. So you should make sure the function is not expecting you to pass an owned ptr.
If you have any control over the interface of process_profile_dta() I would change it. Rather than accepting pointers it should accept references to the object (assuming that it is not taking ownership of the objects passed).
namespace AAAAA_Facade
{
    // Pass values by reference.
    // This allows you to access the original objects.
    // But does not imply any ownership transfer
    void process_profile_dta(prof_pair_class&        prof_pair,
                             fg_prof_analysis_class& fg_prof_analysis,
                             gf_prof_analysis_class& gf_prof_analysis
                            );
}

