juicy problem

[Joshua Moore]

The following code is my attempt to create a program that takes a list
such as this one:
apples taste good
apples are good for you and not expensive at all
you should eat more apples

candy tastes good, too
candy is bad for you and really expensive
you shouldn't eat that much candy
and because i can, a fourth line

and this entry will consist of just one line

<eof>
and write the entries in reverse order, but retaining the order of the
lines within the entry, so the list would look like this:
and this entry will consist of just one line

candy tastes good, too
candy is bad for you and really expensive
you shouldn't eat that much candy
and because i can, a fourth line

apples taste good
apples are good for you and not expensive at all
you should eat more apples

<eof>
What I found so far, is that the variable "start" in object "list" of
class LinkedList is NULL for some reason, but I don't know why.
Can anyone help?

Here comes the code:

//main.cpp
//Joshua Moore
//reverse the order

#include <cstdlib>
#include <iostream>
#include <fstream>
using namespace std;

//The template class for a linked list
//T should have a == operator defined
template <class T>
class LinkedList{
//private members of LinkedList
private:
//the node class
class node{
private:
T data;
node* next;

public:
node(T input){
data = input;
next = NULL;
}

~node(){}

void setData(T d){
data = d;
}

T getData(){
return data;
}

T* getDataP(){
return &data;
}

void setNext(node* n){
next = n;
}

node* getNext(){
return next;
}
};//end of class node

//a pointer to the first node of the list
node* start;

//the number of items in the list
int items;

//the current retrieve data
node* retrieve;

//returns a pointer to the last node
node* lastNode(){
node* temp = start;

//if there are no nodes
if(temp==NULL)
return NULL;

//otherwise move to the next until there is no more next
while(temp->getNext()!=NULL)
temp = temp->getNext();

//return the last node
return temp;
}

//public members of LinkedList
public:
//Constructor
LinkedList(){
start = NULL;
items = 0;
}

//Deconstructor
~LinkedList(){
}

//returns the number of items in the list
int getItems(){
return items;
}

//stores the data given
void store(T data){
//if this node will be at the beginning of the list
if(start==NULL){
//create the first node
start = new node(data);
items++;
}else{
//otherwise create a new node at the end of the list
lastNode()->setNext(new node(data));
items++;
}
cout << "item successfully stored at " << lastNode() << endl;
}//end of store

//returns a pointer to the data containing the argument
T* find(T data){
node* temp = start;

//move on to the next node until there is no next node
while(temp->next!=NULL){
//if the node contains the specified data, return its
if(temp->data==data)
return temp->getDataP();

temp = temp->getNext();
}

//if the node was not found, return NULL
return NULL;
}//end of find

//deletes the first node containing data
void deleteNode(T data){
node* target = find(data);

//if data was not found
if(target==NULL){
//do nothing
}else{
//if the target is the first node
if(target==start){
//save the second node
node* temp = start->getNext();

//delete the first node
delete start;
items--;

//make the saved node the first one
start = temp;
}else{
//otherwise find the node before the target
node* before = start;
while(before->getNext()!=target)
before = before->getNext();

//connect the node before with the node after the target
before->setNext(target->getNext());

//delete the target
delete target;
items--;
}
}
}

//resets retrieve to the first node
void retrieveFirst(){
retrieve = start;
}

//resets retrieve to the last node
void retrieveLast(){
cout << "retrieveLast() was called" << endl;

retrieve = start;
cout << "retrieve set to start" << endl;

cout << "start: " << start << endl;

cout << "retrieve: " << retrieve << endl;

while(retrieve->getNext()!=NULL){
retrieve = retrieve->getNext();
}
}

//sets retrieve to the next node,
//returns true if successful, false if not
bool retrieveNext(){
if(retrieve->getNext()!=NULL){
retrieve = retrieve->getNext();

cout << "retrieveNext() returns true" << endl;
return true;
}else{
cout << "retrieveNext() returns false" << endl;
return false;
}
}

//sets retrieve to the previous node,
//returns true if successful, false if not
bool retrievePrev(){
node* temp = retrieve;
if(temp==start){
return false;
}

while(temp->getNext()!=retrieve){
temp = temp->getNext();
}

retrieve = temp;
return true;
}

//returns the data of current retrieve
T retrieveData(){
return retrieve->getData();
}

//returns a pointer to the data of current retrieve
T* retrieveDataP(){
return retrieve->getDataP();
}

//returns the value of start(just for diagnostics)
T* retrieveStart(){
return start;
}
};//end of class LinkedList

//function prototypes
void readfile(LinkedList< LinkedList<string> > list);
void writefile(LinkedList< LinkedList<string> > list);

int main(int argc, char *argv[])
{
LinkedList< LinkedList<string> > list;

readfile(list);

cout << "==========================" << endl;

writefile(list);

system("PAUSE");
return EXIT_SUCCESS;
}

//file may not be empty
//report entry must end with newline character
void readfile( LinkedList<LinkedList<string> > list){
ifstream input;
input.open("reports.txt");
if(input.fail()){
cerr << "error, couldn't open 'reports.txt'" << endl;
}

string temp;

do{
LinkedList<string> wrapper;

getline(input, temp);
//if there are characters in the line
if(temp.length()>0){
//store lines in a wrapper
wrapper.store(temp);
}else{
//otherwise store wrapper in list
list.store(wrapper);
}
}while(!input.eof());

input.close();
}//readfile

void writefile(LinkedList< LinkedList<string> > list){
ofstream output;
output.open("reports output.txt");
if(output.fail()){
cerr << "error, couldn't open 'reports output.txt'" << endl;
}

cout << "file was successfully opened" << endl;
cout << "list.start: " << list.retrieveStart() << endl;

//set list's retrieve to Last
list.retrieveLast();
cout << "list.retrieveLast()" << endl;

//set wrapper's retrieve to First
list.retrieveDataP()->retrieveFirst();

//write first wrapper's data to file
output << list.retrieveDataP()->retrieveData() << endl;
while(list.retrieveDataP()->retrieveNext()){
output << list.retrieveDataP()->retrieveData() << endl;
}

//write an endline after the first wrapper;
output << "\n";

//write subsequent wrappers' data to file
while(list.retrievePrev()){
output << list.retrieveDataP()->retrieveData() << endl;
while(list.retrieveDataP()->retrieveNext()){
output << list.retrieveDataP()->retrieveData() << endl;
}
//write an endline after the wrapper
output << "\n";
}

output.close();
}//writefile

 

[James Kanze]

The following code is my attempt to create a program that takes a list
such as this one:
apples taste good
apples are good for you and not expensive at all
you should eat more apples

candy tastes good, too
candy is bad for you and really expensive
you shouldn't eat that much candy
and because i can, a fourth line

and this entry will consist of just one line

<eof>
and write the entries in reverse order, but retaining the order of the
lines within the entry, so the list would look like this:
and this entry will consist of just one line

candy tastes good, too
candy is bad for you and really expensive
you shouldn't eat that much candy
and because i can, a fourth line

apples taste good
apples are good for you and not expensive at all
you should eat more apples

<eof>
What I found so far, is that the variable "start" in object "list" of
class LinkedList is NULL for some reason, but I don't know why.
Can anyone help?

Here comes the code:

Wow! What's wrong with something simple like:

std::vector< std::string >
blocks ;
std::string currentBlock ;
std::string line ;
while ( std::getline( std::cin, line ) ) {
if ( line == "" ) {
if ( currentBlock != "" ) {
blocks.push_back( currentBlock ) ;
currentBlock = "" ;
}
} else {
currentBlock += line + '\n' ;
}
}
if ( currentBlock != "" ) {
blocks.push_back( currentBlock ) ;
}
std::reverse_copy(
blocks.begin(), blocks.end(),
std:stream_iterator< std::string >( std::cout,
"\n" ) ) ;

It gets the job done, and it's a hell of a lot less lines than
what you wrote.

[300+ lines of code deleted...]