当前位置: 动力学知识库 > 问答 > 编程问答 >

c++ - Invalid Conversion from 'int' to 'nodeType<int>'

问题描述:

I am trying to create a program that will reverse a linked list using a stack; however, I am continously getting the same error that I cannot set an node equal to an int yet I have seen multiple examples where this was possible! What could I be doing wrong?

Here is the code.

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

};

Exact error on visual studio:

a value of type "int" cannot be assigned to an entity of type "nodeType *"

Any advice would be appreciated.

网友答案:

Firstly, you should change the Type top() const; into nodeType<Type>* top() const; in "linkedStack.h" and "stackADT.h".And you should add template <class Type>struct nodeType; in the "stackADT.h" because linkedStackType derives from stackADT.Additionally, Type top() const should be modified as follows:

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

In this way, I compile the project successfully.

However, there is some algorithm problems in the function void traversal(linkedStackType<int> stack). current and first both are NULL pointer.So what current point to when you use current -> info? I think you should modify this function void traversal(linkedStackType<int> stack).

分享给朋友:
您可能感兴趣的文章:
随机阅读: