Trouble filling a dynamic class template array - c++

Question

Constraints: Cannot use STL for dynamic array implementation.
I've been stuck on this problem for a while now and my research into the answer hasn't yielded anything fruitful yet. Any help would be greatly appreciated!
So I'm trying to write a program that will generate recommendations to users based on the way they have rated various books. In order to do that I need to be able to read in a .txt file that contains a list of authors and titles of books. The format of the .txt is "Author,Book" with each entry on its own line.
I want to fill a dynamic array with Book class objects as I read from the .txt file. Because STL is not allowed for this project, I needed to write my own implementation.
The processing of the file went alright, I was able to display the author and book of each entry on separate lines using cout.
Now I am stuck trying to fill my dynamic array elements with the entries. My class to hold the data is Book and contains a struct of data members.
I am suspicious that the problem is with my function in my dynamic array template implementation.
template<class Recommend>
void DArray<Recommend>::add(const Recommend &obj)
I will eventually want to use this template to hold class objects for users and ratings.
Right now my code appears to fill the array with the proper number of entries, but all but the last element are fill with what looks like Book objects from the default constructor.
Here is the relevant code:
P1.cpp:
//P1.cpp
#include "stdafx.h"
#include "Book.h"
#include "Member.h"
#include "Rating.h"
#include <iostream>
#include <fstream>
using namespace std;
void readBooks(string bookTxt)
{
Book newBook;
DArray<Book> bookArray;
string line;
ifstream file(bookTxt);
if (file.is_open())
{
while (!(file.eof()))
{
getline(file, line, ',');
newBook.bookData.author = line;
getline(file, line, '\n');
newBook.bookData.title = line;
newBook.bookData.year = 2004; //Place holder
newBook.setIsbn();
bookArray.add(newBook);
}
for (int i = ZERO; i < 55; i++)
{
cout << bookArray[i].bookData.author << endl;
cout << bookArray[i].bookData.title << endl;
cout << bookArray[i].bookData.year << endl;
cout << bookArray[i].bookData.isbn << endl;
}
file.close();
}
else cout << "Error: Unable to open file";
}
int main()
{
readBooks("books.txt");
int wait;
cin >> wait;
return 0;
}
Book.h
//Book.h
#ifndef BOOK_H
#define BOOK_H
#include <string>
using namespace std;
const int ZERO = 0;
const int ONE = 1;
template<class Recommend>
class DArray
{
private:
Recommend *array;
int size;
int bitSize;
public:
DArray()
{
size = ZERO;
array = new Recommend[ONE];
}
DArray(int initSize)
{
size = initSize;
array = new Recommend[size];
}
~DArray()
{
delete[] array;
}
DArray(const DArray &rhs);
DArray &operator= (const DArray &rhs);
DArray &operator= (const Recommend &rhs);
Recommend& operator[] (int index);
void add(const Recommend &obj);
int getSize();
void setSize(int size);
void clear();
void remove(int index);
void* getPtr();
};
class Book
{
//Generate a unique int for book ISBN
int generateIsbn();
public:
struct data
{
unsigned long int isbn;
int year;
string title, author;
};
data bookData;
//Constructors (Default and Initializing)
Book()
{
bookData.author = "";
bookData.title = "";
bookData.isbn = ZERO;
bookData.year = ZERO;
}
Book(int initYear, string initTitle, string initAuthor)
{
bookData.author = initAuthor;
bookData.title = initTitle;
bookData.year = initYear;
bookData.isbn = generateIsbn();
}
//Book File IO Functions
void loadFile(ifstream books) const;
void saveFile(ofstream &books);
//Mutator Functions
void addBook(int addYear, string addTitle, string addAuthor);
void setIsbn();
void setYear(data bookData);
void setTitle(data bookData);
void setAuthor(data bookData);
//Accessor Functions
Book getBook(data bookData) const;
unsigned long int getIsbn() const;
int getYear() const;
string getTitle() const;
string getAuthor() const;
};
template<class Recommend>
DArray<Recommend>::DArray(const DArray &rhs)
{
size = rhs.size;
array = new Recommend[size];
for (int i = ZERO; i < size; i++)
array[i] = rhs.array[i];
}
template<class Recommend>
Recommend& DArray<Recommend>::operator[] (int index)
{
return array[index];
}
template<class Recommend>
DArray<Recommend>& DArray<Recommend>::operator= (const DArray &rhs)
{
if (this == &rhs)
return *this;
//if (rhs.size == ZERO)
//clear();
setSize(rhs.size);
for (int i = ZERO; i < size; i++)
array[i] = rhs.array[i];
return *this;
}
template<class Recommend>
DArray<Recommend>& DArray<Recommend>::operator= (const Recommend &rhs)
{
if (this == &rhs)
return *this;
array[size] = rhs;
return *this;
}
template<class Recommend>
int DArray<Recommend>::getSize()
{
return size;
}
template<class Recommend>
void DArray<Recommend>::setSize(int resize)
{
if (resize < 0)
{
Recommend *temp;
temp = new Recommend(resize);
for (int i = ZERO; i < resize; i++)
temp[i] = array[i];
delete[] array;
array = temp;
size = resize;
}
else
clear();
}
template<class Recommend>
void DArray<Recommend>::add(const Recommend &obj)
{
if (size == ZERO)
{
array[ZERO] = obj;
size++;
}
else
{
int newSize = (size + ONE);
Recommend *temp;
temp = new Recommend[newSize];
for (int i = ZERO; i < (size - ONE); i++)
temp[i] = array[i];
temp[(newSize - ONE)] = obj;
delete[] array;
size = newSize;
array = temp;
}
}
template<class Recommend>
void DArray<Recommend>::remove(int index)
{
if (index <= ZERO)
{
if (size == ONE)
clear();
else
{
for (int i = index; i < (size - ONE); i++)
array[i] = array[i + ONE];
size--;
}
}
}
template<class Recommend>
void DArray<Recommend>::clear()
{
delete[] array;
size = 0;
}
template<class Recommend>
void* DArray<Recommend>::getPtr()
{
return array;
}
#endif
Book.cpp:
//Book.cpp
#include "stdafx.h"
#include "Book.h"
const unsigned long int ISBN_MIN = 100000;
const unsigned long int ISBN_MAX = 999999;
//Generate a unique isbn
int Book::generateIsbn()
{
unsigned long long int isbn;
isbn = this->bookData.title.length();
isbn += this->bookData.title.size();
isbn += this->bookData.author.length();
isbn += this->bookData.title.capacity();
isbn += this->bookData.author.size();
isbn += this->bookData.author.capacity();
isbn *= this->bookData.year;
isbn = isbn % ISBN_MAX + ISBN_MIN;
isbn += this->bookData.author[ONE];
isbn += this->bookData.title[ONE];
isbn += this->bookData.author[ZERO];
isbn += this->bookData.title[ZERO];
static_cast<int>(isbn);
return isbn;
}
void Book::addBook(int addYear, string addTitle, string addAuthor)
{
bookData.author = addAuthor;
bookData.title = addTitle;
bookData.year = addYear;
bookData.isbn = generateIsbn();
}
unsigned long int Book::getIsbn() const
{
return bookData.isbn;
}
void Book::setIsbn()
{
this->bookData.isbn = generateIsbn();
}
A sample of book.txt
Neil Shusterman,The Shadow Club
Jeff Smith,Bone Series
Art Spiegelman,Maus: A Survivor's Tale
Amy Tan,The Joy Luck Club
J R R Tolkien,The Lord of the Rings
J R R Tolkien,The Hobbit
Eric Walters,Shattered
H G Wells,The War Of The Worlds
Patricia C. Wrede,Dealing with Dragons
John Wyndham,The Chrysalids
Sample of the output:
0
0
0
0
0
0
0
0
John Wyndham
The Chrysalids
2004
360893
I feel bad about asking for help, but I'm really stuck here. Thank you in advance.

Answer 1

Inside DArray::add when you copy the values from the old array you check for i < (size - ONE), that skips the last item, since you do it each time you add an item nothing gets copied and only the last item added remains.