10 years of FIF
10 years of FIF
10 years of FIF ok so heres the problem , ill need help on the code but the problem is the worst part
10 years of FIF
10 years of FIF
10 years of FIF I could explain what i'd do, but cant give you the code. Maybe elnino or fitzy can
10 years of FIFThat's the thing, you dont NEED to learn C++ to learn java. It's better for understanding lists though.
And you, i was wondering if you are alive. Where the fuck have you been?
As for the problem, i havent touched c++ for over 3 years, so i can hardly be of any help. Sry
?
10 years of FIF
Forum Supporter10 years of FIF
10 years of FIFYeah. The main tracks should be implemented with double linked lists, i think it is the best. The t1 and t2 with stacks. If the train is parked, and another comes in, i guess the second that came must get out first, and than the other, that;s the stack.
What is the engine actually, some value? If so, than the "train" must start with that value, which will represent the engine. For disconnecting trains, you will need a function that separates one big list in two or more smaller ones. As for the aprking, i have no idea how to make it
10 years of FIF
10 years of FIF
// This program demonstrates the DynIntQeue class.
#include <iostream>
#ifndef DYNINTQUEUE_H
#define DYNINTQUEUE_H
using namespace std;
////////////////////////////////////////////////////////////////////////
class DynIntQueue
{
private:
// Structure for the queue nodes
struct QueueNode
{
int value; // Value in a node
QueueNode *next; // Pointer to the next node
};
QueueNode *front; // The front of the queue
QueueNode *rear; // The rear of the queue
int numItems; // Number of items in the queue
public:
// Constructor
DynIntQueue();
// Destructor
~DynIntQueue();
// Queue operations
void enqueue(int);
void dequeue(int &);
bool isEmpty() const;
bool isFull() const;
void clear();
};
////////////////////////////////////////////////////////////////////////
//**************************************************
// Destructor *
// This function deletes every node in the list. *
//**************************************************
DynIntStack::~DynIntStack()
{
StackNode *nodePtr, *nextNode;
// Position nodePtr at the top of the stack.
nodePtr = top;
// Traverse the list deleting each node.
while (nodePtr != NULL)
{
nextNode = nodePtr->next;
delete nodePtr;
nodePtr = nextNode;
}
}
//************************************************
// Member function push pushes the argument onto *
// the stack. *
//************************************************
void DynIntStack::push(int num)
{
StackNode *newNode; // Pointer to a new node
// Allocate a new node and store num there.
newNode = new StackNode;
newNode->value = num;
// If there are no nodes in the list
// make newNode the first node.
if (isEmpty())
{
top = newNode;
newNode->next = NULL;
}
else // Otherwise, insert NewNode before top.
{
newNode->next = top;
top = newNode;
}
}
//****************************************************
// Member function pop pops the value at the top *
// of the stack off, and copies it into the variable *
// passed as an argument. *
//****************************************************
void DynIntStack::pop(int &num)
{
StackNode *temp; // Temporary pointer
// First make sure the stack isn't empty.
if (isEmpty())
{
cout << "The stack is empty.\n";
}
else // pop value off top of stack
{
num = top->value;
temp = top->next;
delete top;
top = temp;
}
}
//****************************************************
// Member function isEmpty returns true if the stack *
// is empty, or false otherwise. *
//****************************************************
bool DynIntStack::isEmpty()
{
bool status;
if (!top)
status = true;
else
status = false;
return status;
}
///////////////////////////////////////////////////////////////////////////////
int main()
{
const int MAX_VALUES = 5;
// Create a DynIntQueue object.
DynIntQueue iQueue;
// Enqueue a series of numbers.
cout << "Enqueuing " << MAX_VALUES << " items...\n";
for (int x = 0; x < 5; x++)
iQueue.enqueue(x);
// Dequeue and retrieve all numbers in the queue
cout << "The values in the queue were:\n";
while (!iQueue.isEmpty())
{
int value;
iQueue.dequeue(value);
cout << value << endl;
}
system("pause");
return 0;
}Yeah. The main tracks should be implemented with double linked lists, i think it is the best. The t1 and t2 with stacks. If the train is parked, and another comes in, i guess the second that came must get out first, and than the other, that;s the stack.
What is the engine actually, some value? If so, than the "train" must start with that value, which will represent the engine. For disconnecting trains, you will need a function that separates one big list in two or more smaller ones. As for the aprking, i have no idea how to make it
10 years of FIF Not lists as well, never learned pointers like i should lol
10 years of FIFIn Java yes, in c++, not really
lol i need to make a binary tree for a menu .. sounds easy ehh
10 years of FIF