Using C++I keep getting messagehead does not name a type.pdf

Using C++
I keep getting message:
'head does not name a type'
'teal does not name a type'
Where do I place this code in my program:
/*search and delete with respect to location as current, head and tail
//define below 2 lines in LinkedList() function
head = new NodeType;
tail = new NodeType;
void UnsorderedType::DeleteItem(ItemType item)
{
NodeType *tempLocation, *location;
bool stop = false;
if(!isEmpty())
{
location = head;
tempLocation = head->link;
while (templocation != tail && !stop)
{
if (templocation->info == item)
stop = true;
else
{
location = templocation;
templocation = templocation->link;
}
}
if (!stop)
cout << "The node to delete is not in the list!" << endl;
else
{
location->link = templocation->link;

delete templocation;
count--;
}
}
else
{
cout << "The list is empty!" << endl;
}
}*/
/Problem and code:
Implement the UnsortedList class to store a list of strings that are input into the list from
data2.txt.
- create a main.cpp file that gets the numbers from the file
- insert the word "cat" into the list
- insert another word "antibacterial" into the list
- delete the word "letter" from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file one called
outfile1.txt
- Yes you need to make your program output an "outfile1.txt"
3. Implement the UnsortedList class to store a list of numbers that are input into the list from
data.txt.
- create a main.cpp file that gets the numbers from the file
- insert the number 7 into the list
- insert another number 300 into the list
- delete the number 6 from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file two called
outfile2.txt
- Yes you need to make your program output an "outfile2.txt"

data.txt
super formula travel free thick Josephine Clara education
data2.txt
super formula travel free thick Josephine Clara education
//My main.cpp
//--------------------------------------------------------------
// Test driver for Linked List UnsortedType list
// Navarr Barnier
// Your class CS3350 TTh 1:00
// Due date: Thursday, September 13, 2012
//
// Compile command: g++ hw2.cpp ch03-UnsortedType.cpp ch03-ItemType.cpp
// Input file name: hw2.txt
// Contains list of commands to add items to list, split original
// list into two lists, print each list and get the length of
// each list.
// Output: The result of each command is displayed on the screen.
// Filename: hw2.cpp
//--------------------------------------------------------------
#include
#include
#include
#include
#include
#include "ItemType.h"
using namespace std;
void PrintList(UnsortedType&);
void SplitList(UnsortedType&, ItemType);
ItemType GetItem(ItemType& item, bool& found);
int main()
{
ifstream inFile; // file containing operations
ofstream outFS; // Output file stream
string data; // operation to be executed
string command; // operation to be executed
int count = 0;

ItemType item;
UnsortedType list;
bool found;
//int numCommands;
//----------------------------------------
// Open input file with commands for testing
// list operations, check success of open
//----------------------------------------
inFile.open("data2.txt");
if (!inFile)
{
cout << "Unable to open input file - ending program." << endl;
return 1;
}
//----------------------------------------
// Read in and process commands to apply to list
//----------------------------------------
//inFile >> data;
//numCommands = 0;
while (!inFile.eof())
{
//numCommands++;
//cout << "Command " << numCommands << ": " << command << " ";
//----------------------------------------
// PutItem
//----------------------------------------
inFile >> data;
item.Initialize(data);
list.PutItem(item);
++count;
item.Print();
cout << ", " << "added to list" << endl;
}
inFile.close();
cout << " " << count << " words total in list." << " ";
inFile.open("hw6.txt");

if (!inFile)
{
cout << "Unable to open input file - ending program." << endl;
return 1;
}
//----------------------------------------
// Read in and process commands to apply to list
//----------------------------------------
inFile >> command;
//numCommands = 0;
while (command != "Quit")
{
// numCommands++;
// cout << "Command " << numCommands << ": " << command << " ";
//----------------------------------------
// PutItem
//----------------------------------------
if (command == "PutItem")
{
inFile >> data;
list.PutItem(item);
item.Print();
cout << " added to list" << endl;
}
//----------------------------------------
// GetItem
//----------------------------------------
else if (command == "GetItem")
{
inFile >> data;
item = list.GetItem(item, found);
item.Print();
if (found)
cout << " found in list." << endl;

else
cout << " not in list." << endl;
}
//----------------------------------------
// DeleteItem
//----------------------------------------
else if (command == "DeleteItem")
{
inFile >> data;
list.DeleteItem(item);
item.Print();
cout << " deleted from list" << endl;
}
//----------------------------------------
// GetLength
//----------------------------------------
else if (command == "GetLength")
cout << "Length of list = " << list.GetLength() << endl;
//----------------------------------------
// IsFull
//----------------------------------------
else if (command == "IsFull")
if (list.IsFull())
cout << "List is full." << endl;
else
cout << "List is not full." << endl;
//----------------------------------------
// MakeEmpty
//----------------------------------------
else if (command == "MakeEmpty")
{ list.MakeEmpty();
cout << "List is empty." << endl;
}
//----------------------------------------
// PrintList

// Non-member function to print list of items
//----------------------------------------
else if (command == "PrintList")
{
cout << " List values" << endl;
PrintList(list);
}
//----------------------------------------
// SplitList
// Split the list
//----------------------------------------
else if (command == "SplitList")
{
inFile >> data;
//SplitList(list,item);
}
//----------------------------------------
// Invalid command
//----------------------------------------
else
cout << command << " is not a valid command." << endl;
inFile >> command;
};
cout << "Testing completed." << endl;
inFile.close();
/*//----------------------------------------
// PutItem
//----------------------------------------
if (command == "PutItem")
{
inFile >> data;
list.PutItem(item);
item.Print();
cout << " added to list" << endl;

}
//----------------------------------------
// GetItem
//----------------------------------------
else if (command == "GetItem")
{
inFile >> data;
item = list.GetItem(item, found);
item.Print();
if (found)
cout << " found in list." << endl;
else
cout << " not in list." << endl;
}
//----------------------------------------
// DeleteItem
//----------------------------------------
else if (command == "DeleteItem")
{
inFile >> data;
list.DeleteItem(item);
item.Print();
cout << " deleted from list" << endl;
}
//----------------------------------------
// PrintList
// Non-member function to print list of items
//----------------------------------------
else if (command == "PrintList")
{
cout << " List values" << endl;
PrintList(list);
}
*/

return 0;
}
//----------------------------------------
// PrintList
// Non-member function to print all items in list
// Pre: list has been initialized
// Post: Each component in list has been written to cout
//----------------------------------------
void PrintList(UnsortedType &list)
{
int length;
ItemType item;
list.ResetList();
length = list.GetLength();
for (int counter = 1; counter <= length; counter++)
{
item = list.GetNextItem();
item.Print();
cout << endl;
}
cout << "Length of list = " << length << endl << endl;
}
//My UnsortedList.cpp Code
//------------------------------------------------------
// ItemType
// Class Implementation File
// Ch. 3, C++ Plus Data Structures, Dale 5e, p. 155
// Filename: ch03-ItemType.cpp
//------------------------------------------------------
#include
#include
#include "ItemType.h"
//------------------------------
// ItemType
// default constructor

//------------------------------
ItemType::ItemType()
{ value = ""; }
//------------------------------
// ComparedTo
// Compares one ItemType object to another. Returns
// LESS, if self "comes before" item
// GREATER, if self "comes after" item
// EQUAL, if self and item are the same
//------------------------------
RelationType ItemType::ComparedTo(ItemType otherItem) const
{
if (value < otherItem.value)
return LESS;
else if (value > otherItem.value)
return GREATER;
else return EQUAL;
}
//------------------------------
// Initialize
//------------------------------
void ItemType::Initialize(string data)
{ value = data; }
//------------------------------
// Print
// Adds ItemType value to output stream
//------------------------------
void ItemType::Print() const
// pre: out has been opened.
// post: value has been sent to the stream cout.
{ cout << value; }
//------------------------------------------------------
// UnsortedType
// Linked List - Class Implementation File
// Your name
// Your class CS3350 classtime

//------------------------------------------------------
//---------------------------------------------
// Constructor
//---------------------------------------------
UnsortedType::UnsortedType()
{
length = 0;
listData = NULL;
}
//---------------------------------------------
// Destructor
// Deallocates all items in list
// Post: List is empty
// All items have been deallocated
//---------------------------------------------
UnsortedType::~UnsortedType()
{
NodeType* tempPtr;
// Loop removes all nodes from list
// deallocating space for each one
while(listData != NULL)
{
tempPtr = listData;
listData = listData->next;
delete tempPtr;
}
}
//---------------------------------------------
// MakeEmpty
// Returns the list to the empty state
//---------------------------------------------
void UnsortedType::MakeEmpty()
{

NodeType* tempPtr;
// Loop removes all nodes from list
// deallocating space for each one
while(listData != NULL)
{
tempPtr = listData;
delete tempPtr;
}
length = 0;
}
//---------------------------------------------
// IsFull
// Function: Determines whether list is full.
// Pre: List has been initialized.
// Post: Function value = (list is full)
// Returns: true if there is no room for another
// ItemType on the free store; false otherwise.
//---------------------------------------------
bool UnsortedType::IsFull() const
{
NodeType* location;
// Try adding a new node, if successful, there
// is room for more nodes so list is NOT full
try
{
location = new NodeType;
delete location;
return false;
}
// If adding a new node was unsuccessful,
// the list is full
catch(bad_alloc)
{
return true;
}

}
//---------------------------------------------
// GetLength
// Determines number of elements in list
// Pre: List has been initialized
// Post: Number of items in the list is returned
//---------------------------------------------
int UnsortedType::GetLength() const
{
return length;
}
//---------------------------------------------
// PutItem
// Adds item to list
// List is not full
// item is not in list
// Post: item is in list; length has been incremented
//---------------------------------------------
void UnsortedType::PutItem(ItemType item)
{
NodeType* location = new NodeType;
location->info = item;
location->next = listData;
listData = location;
length++; // Increment length of list
}
//---------------------------------------------
// GetItem
// Retrieves list element whose key matches item's key (if present)
// Key member of item is initialized.
// Post: If there is an element someItem whose key matches
// item's key, then found = true and someItem is returned;
// otherwise found = false and item is returned unchanged.
// List is unchanged.

//---------------------------------------------
ItemType UnsortedType::GetItem(ItemType& item, bool& found)
{
bool moreToSearch;
NodeType* location;
location = listData;
found = false;
moreToSearch = (location != NULL);
while (moreToSearch && !found)
{
switch (item.ComparedTo(location->info))
{
case LESS :
case GREATER : location = location->next;
moreToSearch = (location != NULL);
break;
case EQUAL : found = true;
item = location->info;
break;
}
}
return item;
}
//---------------------------------------------
// DeleteItem
// Deletes the element whose key matches item's key.
// Key member of item is initialized.
// One and only one element in list has a key
// matching item's key.
// Post: No element in list has a key matching item's key.
//---------------------------------------------
void UnsortedType::DeleteItem(ItemType item)
{
NodeType* location;
NodeType* tempLocation;

location = listData;
if (item.ComparedTo(location->info) == EQUAL)
{
tempLocation = location;
}
else
{
while (!((item.ComparedTo((location->next)->info) == EQUAL)))
break;
location = location->next;
tempLocation = location->next;
location->next = (location->next)->next;
}
delete tempLocation;
length--;
}
//---------------------------------------------
// ResetList
// Initializes current position for an iteration through the list
// Post: Current position has been initialized
// and is prior to list
//---------------------------------------------
void UnsortedType::ResetList()
{
currentPos = NULL;
}
//---------------------------------------------
// GetNextItem
// Gets next element in list
// Pre: ResetList was called to initialize iteration
// No transformer has been executed since last call
// Current position is defined.
// Post: item is copy of element at current position
// Current position is updated to next position

// Returns: copy of next item in list
//---------------------------------------------
ItemType UnsortedType::GetNextItem()
{
if (currentPos == NULL)
currentPos = listData;
else
currentPos = currentPos->next;
return currentPos->info;
}
//My ItemType.h Code
//------------------------------------------------------
// ItemType
// Class Specification File
// Encapsulates type of items in list
// Ch. 3, C++ Plus Data Structures, Dale 5e, p. 154, 155
// same as code from Ch. 4 ItemType.h
// Filename: ch03-ItemType.h
//------------------------------------------------------
#include
#ifndef ITEMTYPE_H
#define ITEMTYPE_H
const int MAX_ITEMS = 25;
enum RelationType {LESS, GREATER, EQUAL};
class ItemType
{
private:
string value;
public:
ItemType();
RelationType ComparedTo(ItemType) const;
void Print() const;
void Initialize(string data);
};
//------------------------------------------------------

// UnsortedType
// Linked List - Class Specification File
// Your name
// Your class CS3350 classtime
//
// Defines an unsorted list type whose elements are of ItemType
// Ch. 3, C++ Plus Data Structures, Dale 5e, p. 183-185
// Filename: hw2-UnsortedType.h
// File ch03-ItemType.h must be provided by the user of this class.
// It must contain the following definitions:
// MAX_ITEMS: the maximum number of items on the list
// RelationType: {LESS, GREATER, EQUAL}, an enumerated type
// ItemType: class with definition of the objects in the list
//------------------------------------------------------
class UnsortedType
{
private:
struct NodeType
{
ItemType info;
NodeType* next;
};
NodeType* listData; // Pointer to head of list
int length; // # of items (nodes) in list
NodeType* currentPos;
public:
UnsortedType(); // Constructor
~UnsortedType(); // Destructor
void MakeEmpty(); // Returns the list to the empty state
bool IsFull() const; // Determines whether list is full
int GetLength() const; // Determines the number of elements in list
ItemType GetItem(ItemType& item, bool& found);
// Retrieves list element whose key
// matches item's key (if present)
void PutItem(ItemType item); // Adds item to list

void DeleteItem(ItemType item); // Deletes element whose key
// matches item's key.
void ResetList(); // Initializes current position for
// an iteration through the list
ItemType GetNextItem(); // Gets the next element in list
//void SplitList(ItemType item, UnsortedType &list1, UnsortedType &list2);
// Splits a list into two based on the item
};
#endif // CH03-ITEMTYPE_H_INCLUDED
Solution
The error you are geting for head and tail is because the compiler is not able to find NodeType.
That means you have defined it later but used it before it was known by compiler.
At first, you are having a method DeleteItem() that you need to define. It is already declared in
ItemType.h class
UnsortedType.
Now, to write this code, you will have to go to the file where its implementation is written, Here
it is UnsortedList.cpp.
So, go to the UnsortedList.cpp file. There is a DeleteItem() method already written. You replace
it with the code you have written in the question's starting (from head = ........). This is needed
because the instructions in the comment says that. So, replace it with the code you provided in
starting of the question. This will work for sure.
Do comment for any query. I will address it for sure. Thank you. :)

Using C++I keep getting messagehead does not name a type.pdf

Recommended

Recommended

More Related Content

Similar to Using C++I keep getting messagehead does not name a type.pdf

Similar to Using C++I keep getting messagehead does not name a type.pdf (20)

More from alokkesh1

More from alokkesh1 (20)

Recently uploaded

Recently uploaded (20)

Using C++I keep getting messagehead does not name a type.pdf