Thread: Need help with Stack to print the prime factors in descending order.

I am writing code I am having difficulty with this one area. I am supposed to Write a program that uses a stack to print the prime factors of a positive integer (input by the user) in descending order. I am attaching my code below. Any help would be greatly appreciated.

linkedStack.h

Code:

//Header File: linkedStack.h
 
#ifndef H_StackType
#define H_StackType
 
#include <iostream>
#include <cassert>
#include "stackADT.h"
 
using namespace std;
//Definition of the node
template <class Type>
struct nodeType
{
    Type info;
    nodeType<Type> *link;
};
template <class Type>
class linkedStackType: public stackADT<Type>
{
public:
    const linkedStackType<Type>& operator=
                              (const linkedStackType<Type>&);
      //Overload the assignment operator.
    bool isEmptyStack() const;
      //Function to determine whether the stack is empty.
      //Postcondition: Returns true if the stack is empty;
      //               otherwise returns false.
    bool isFullStack() const;
      //Function to determine whether the stack is full.
      //Postcondition: Returns false.
    void initializeStack();
      //Function to initialize the stack to an empty state.
      //Postcondition: The stack elements are removed;
      //               stackTop = nullptr;
    void push(const Type& newItem);
      //Function to add newItem to the stack.
      //Precondition: The stack exists and is not full.
      //Postcondition: The stack is changed and newItem
      //               is added to the top of the stack.
    Type top() const;
      //Function to return the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: If the stack is empty, the program
      //               terminates; otherwise, the top
      //               element of the stack is returned.
    void pop();
      //Function to remove the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: The stack is changed and the top
      //               element is removed from the stack.
    linkedStackType();
      //Default constructor
      //Postcondition: stackTop = nullptr;
    linkedStackType(const linkedStackType<Type>& otherStack);
      //Copy constructor
    ~linkedStackType();
      //Destructor
      //Postcondition: All the elements of the stack are
      //               removed from the stack.
private:
    nodeType<Type> *stackTop; //pointer to the stack
    void copyStack(const linkedStackType<Type>& otherStack);
      //Function to make a copy of otherStack.
      //Postcondition: A copy of otherStack is created and
      //               assigned to this stack.
};
    //Default constructor
template <class Type>
linkedStackType<Type>::linkedStackType()
{
    stackTop = nullptr;
}
template <class Type>
bool linkedStackType<Type>::isEmptyStack() const
{
    return(stackTop == nullptr);
} //end isEmptyStack
template <class Type>
bool linkedStackType<Type>:: isFullStack() const
{
    return false;
} //end isFullStack
template <class Type>
void linkedStackType<Type>::initializeStack()
{
    nodeType<Type> *temp; //pointer to delete the node
    while (stackTop != nullptr)    //while there are elements in
                                //the stack
    {
        temp = stackTop;    //set temp to point to the
                            //current node
        stackTop = stackTop->link;  //advance stackTop to the
                                    //next node
        delete temp;    //deallocate memory occupied by temp
    }
} //end initializeStack
template <class Type>
void linkedStackType<Type>::push(const Type& newElement)
{
    nodeType<Type> *newNode;  //pointer to create the new node
    newNode = new nodeType<Type>; //create the node
    newNode->info = newElement; //store newElement in the node
    newNode->link = stackTop; //insert newNode before stackTop
    stackTop = newNode;       //set stackTop to point to the
                              //top node
} //end push
template <class Type>
Type linkedStackType<Type>::top() const
{
    assert(stackTop != nullptr); //if stack is empty,
                              //terminate the program
    return stackTop->info;    //return the top element
}//end top
template <class Type>
void linkedStackType<Type>::pop()
{
    nodeType<Type> *temp;   //pointer to deallocate memory
    if (stackTop != nullptr)
    {
        temp = stackTop;  //set temp to point to the top node
        stackTop = stackTop->link;  //advance stackTop to the
                                    //next node
        delete temp;    //delete the top node
    }
    else
        cout << "Cannot remove from an empty stack." << endl;
}//end pop
template <class Type>
void linkedStackType<Type>::copyStack
                     (const linkedStackType<Type>& otherStack)
{
    nodeType<Type> *newNode, *current, *last;
    if (stackTop != nullptr) //if stack is nonempty, make it empty
        initializeStack();
    if (otherStack.stackTop == nullptr)
        stackTop = nullptr;
    else
    {
        current = otherStack.stackTop;  //set current to point
                                   //to the stack to be copied
            //copy the stackTop element of the stack
        stackTop = new nodeType<Type>;  //create the node
        stackTop->info = current->info; //copy the info
        stackTop->link = nullptr;  //set the link field of the
                                //node to nullptr
        last = stackTop;        //set last to point to the node
        current = current->link;    //set current to point to
                                    //the next node
            //copy the remaining stack
        while (current != nullptr)
        {
            newNode = new nodeType<Type>;
            newNode->info = current->info;
            newNode->link = nullptr;
            last->link = newNode;
            last = newNode;
            current = current->link;
        }//end while
    }//end else
} //end copyStack
    //copy constructor
template <class Type>   
linkedStackType<Type>::linkedStackType(
                      const linkedStackType<Type>& otherStack)
{
    stackTop = nullptr;
    copyStack(otherStack);
}//end copy constructor
    //destructor
template <class Type>
linkedStackType<Type>::~linkedStackType()
{
    initializeStack();
}//end destructor
    //overloading the assignment operator
template <class Type>   
const linkedStackType<Type>& linkedStackType<Type>::operator=
                  (const linkedStackType<Type>& otherStack)
{
    if (this != &otherStack) //avoid self-copy
        copyStack(otherStack);
    return *this;
}//end operator=
#endif

stackADT.h

Code:

#ifndef H_StackADT
#define H_StackADT
 
template <class Type>
class stackADT
{
public:
    virtual void initializeStack() = 0;
       //Method to initialize the stack to an empty state.
       //Postcondition: Stack is empty
    virtual bool isEmptyStack() const = 0;
      //Function to determine whether the stack is empty.
      //Postcondition: Returns true if the stack is empty,
      //               otherwise returns false.
    virtual bool isFullStack() const = 0;
      //Function to determine whether the stack is full.
      //Postcondition: Returns true if the stack is full,
      //               otherwise returns false.
    virtual void push(const Type& newItem) = 0;
      //Function to add newItem to the stack.
      //Precondition: The stack exists and is not full.
      //Postcondition: The stack is changed and newItem
      //               is added to the top of the stack.
    virtual Type top() const = 0;
      //Function to return the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: If the stack is empty, the program
      //               terminates; otherwise, the top element
      //               of the stack is returned.
    virtual void pop() = 0;
      //Function to remove the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: The stack is changed and the top
      //               element is removed from the stack.
};        
#endif

main.cpp

Code:

#include <iostream>
#include "stackADT.h"
#include "linkedStack.h"

using namespace std;

int main() {

cout << "\n\n\tThis will print prime factor of positive integers in a decending order";

linkedStackType<int> stack ( 15 );
    
    int number;
    
    cout << "\n\tEnter a positive number:";
    cin >> number;
    
    for ( int n = 2; n <=number; n++ )
    {
        if ( prime ( n ) && ( ( number % n ) == 0 ) )
            stack.push ( n );
    }
    
    cout <<"\ntPrime factors descending are: ";
    while (!stack.isEmptyStack())
    {
        cout << stack.top() << " ";
        stack.pop();
    }
    
    cout <<"\n\n\t";
    system("pause");
    return 0;
}

Originally Posted by whiteflags

It would appear that the basic problems are:

1: You haven't defined prime(n) anywhere
2: When you try to make a linkedStack of ints, there is no constructor that takes an argument of type int.

Once these issues are fixed, the program at least appears to work.

Code:

C:\Users\jk\Desktop\sandbox>a


        This will print prime factor of positive integers in a decending order
        Enter a positive number:15

tPrime factors descending are: 5 3

        Press any key to continue . . .

C:\Users\jk\Desktop\sandbox>a


        This will print prime factor of positive integers in a decending order
        Enter a positive number:101

tPrime factors descending are: 101

        Press any key to continue . . .

C:\Users\jk\Desktop\sandbox>a


        This will print prime factor of positive integers in a decending order
        Enter a positive number:156462

tPrime factors descending are: 293 89 3 2

        Press any key to continue . . .

Although I guess that you would need to fix the tab for the phrase "Prime factors descending are:"

Can you post the modified code so I can see what you are referring to please?