'int'から 'nodeType <int>'への無効な変換

Question

スタックを使用してリンクリストを逆転させるプログラムを作成しようとしています。しかし、私は継続的に同じエラーを取得していますが、ノードをintに設定することはできませんが、これが可能な場合は複数の例があります。私は何が間違っていますか？

ここにコードがあります。

#include<iostream> 
#include<fstream> 

using namespace std; 


#include "linkedStack.h" 
nodeType<int> *head = NULL; 
void traversal(linkedStackType<int>); 

int main(){ 

    linkedStackType<int> Estack; 
    linkedStackType<int> Ostack; 
    linkedStackType<int> Tstack; 
    Estack.initializeStack(); 
    Ostack.initializeStack(); 
    int num; 

    for (int i = 0; i < 10; i++) 
    { 
    cout << "Hello! Enter a number.\n"; 
    cin >> num; 
     if (num % 2 == 0) 
     { 
      cout << "This number is even! It's going to the even stack.\n"; 
      Estack.push(num); 
     } 
     else 
     { 
      cout << "This number is odd! It's going to the odd stack.\n"; 
      Ostack.push(num); 
     } 
    } 
    traversal(Estack); 
    traversal(Ostack); 

    system("Pause"); 
    return 0; 
} 
void traversal(linkedStackType<int> stack) 
{ 
    nodeType<int> *current = NULL, *first = NULL; 
     current = first; 
     while (current != NULL) { 
     stack.push(current->info); 
     current = current->link; 
    } 
    while (stack.isEmptyStack() != true){ 
     current=stack.top(); 
     stack.pop(); 
     cout << current->info << " "; 
    } 
} 

linkedStack.h

#ifndef H_StackType 
#define H_StackType 

#include <iostream> 
#include <cassert> 
using namespace std; 

#include "stackADT.h" 

template <class Type> 
struct nodeType 
{ 
    Type info; 
    nodeType<Type> *link; 
}; 

template <class Type> 
class linkedStackType :public stackADT<Type> 
{ 
public: 
    linkedStackType(); 

    //Default constructor 
    //Postcondition: stackTop = NULL; 

    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. 
    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 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. 

    void initializeStack(); 

    //Function to initialize the stack to an empty state. 
    //Postcondition: The stack elements are removed; 
    // stackTop = NULL; 
    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(const linkedStackType<Type>& otherStack); 
    //Copy constructor 
    //~linkedStackType(); 

    //Destructor 
    //Postcondition: All the elements of the stack are removed 
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. 
}; 


template <class Type> 
linkedStackType<Type>::linkedStackType() 
{ 
    stackTop = NULL; 
} 

template <class Type> 
bool linkedStackType<Type>::isEmptyStack() const 

{ 
    return(stackTop == NULL); 
} //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 != NULL) //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> 
void linkedStackType<Type>::pop() 

{ 
    nodeType<Type> *temp; //pointer to deallocate memory 
    if (stackTop != NULL) 

    { 
     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> 
Type linkedStackType<Type>::top() const 
{ 
    assert(stackTop != NULL); //if stack is empty, 
           //terminate the program 
    return stackTop->info; //return the top element 
}//end top 

template <class Type> 
void linkedStackType<Type>::copyStack(const linkedStackType<Type>& otherStack) 
{ 
    nodeType<Type> *newNode, *current, *last; 
    if (stackTop != NULL) //if stack is nonempty, make it empty 
     initializeStack(); 
    if (otherStack.stackTop == NULL) 
     stackTop = NULL; 
    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 = NULL; //set the link field to NULL 
     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 != NULL) 

      { 
       newNode = new nodeType<Type>; 
       newNode->info = current->info; 
       newNode->link = NULL; 
       last->link = newNode; 
       last = newNode; 
       current = current->link; 
      }//end while 
    }//end else 
} //end copyStack 

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= 
template <class Type> 

linkedStackType<Type>::linkedStackType(const linkedStackType<Type>& otherStack) 
{ 
    stackTop = NULL; 
    copyStack(otherStack); 
}//end copy constructor 



#endif 

stackADT.h

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. 

}; 

のVisual Studio上

正確なエラー：

"INT" 型の値は、エンティティに割り当てることはできません

タイプ「nodeType *」

アドバイスをいただければ幸いです。

Answer 1

まず、あなたは次のようにlinkedStackTypeがstackADT .Additionally、Type top() constから派生しているため、あなたが「stackADT.h」でtemplate <class Type>struct nodeType;を追加する必要があり"linkedStack.h"でnodeType<Type>* top() const;にType top() const;と"stackADT.h" .ANDを変更する必要が変更する必要があります。

template <class Type> 
nodeType<Type>* linkedStackType<Type>::top() const 
{ 
    assert(stackTop != NULL); //if stack is empty, 
           //terminate the program 
    return stackTop; //return the top element 
}//end top 

このようにして、プロジェクトを正常にコンパイルします。

ただし、関数void traversal(linkedStackType<int> stack)にはいくつかのアルゴリズムの問​​題があります。 currentとfirstは両方ともNULLポインタです。何をcurrentに指したらuse current -> info？私はあなたがこの機能を変更する必要があると思う。void traversal(linkedStackType<int> stack)。