New C++ coder w/difficulty on scope/visibility in queue example - c++

Question

All,
I asked a question last week and I thank you for your tolerance in answering. I'm overall an inexperienced coder but have dabbled most of my life. This is the hardest language/class I've ever taken and it's driving me nuts that I can't get some of these concepts. I've done quite a bit of googling and found some helpful things but never something quite similar enough to fix what I've run into.
ALSO: I am not that familiar with the SO interface, so wasn't sure last time how to 'mark' an answer as the best to give credit to those who helped. I didn't see a way to respond to other smaller comments. A lot in here, but I want to do the right thing for you folks taking the time to help others.
The assignment is to create a queue class with five files described as follows:
QueueItem.h contains the class definition for QueueItem
QueueItem.cpp contains the member function implementations for QueueItem.
Queue.h contains the class definition for Queue.
Queue.cpp contains the member function implementations for Queue.
main.cpp contains the main() test function.
Queue.h
#pragma once
#include "QueueItem.h"
class Queue {
public:
Queue(); // ctor inits a new empty Queue
~Queue(); // dtor erases any remaining QueueItems
void addItem(const char* pData);
void removeItem();
void print();
void erase();
private:
QueueItem* _pHead; // always points to first QueueItem in the list
QueueItem* _pTail; // always points to the last QueueItem in the list
int _itemCounter; // always increasing for a unique id to assign to each new QueueItem
};
In Queue.cpp below, there are two places where I think the code should either be _pTail->_pNext or _pTail._pNext. If it's the ->, then I get C++ member (declared at line 21 of) is inaccessible but using the . gives C++ expression must have class type. This is definitely one of the places where I think it's a conceptual thing I'm not understanding because I think it should be the -> but have no idea how to make that accessible.
Queue.cpp
#include "Queue.h"
#include "QueueItem.h"
#include <iostream>
using namespace std;
void Queue::addItem(const char* pData) {
// dynamically create and init a new QueueItem object
QueueItem* pItem = new QueueItem(pData, ++_itemCounter);
if (0 == _pHead) // check for empty queue
_pHead = _pTail = pItem;
else {
// link new item onto tail of list using _pTail pointer
_pTail->_pNext = pItem; // links the current pTail to the new pItem
_pTail = pItem; // move the pTail to the new item
}
}
void Queue::removeItem() {
// check for empty queue
if (0 == _pHead)
{ // if empty, nothing to do
}
else
{
// pop top item off
QueueItem* popped = _pHead; // create popped to hold value of _pHead
_pHead = popped->_pNext; // Move the pHead to the next in queue
delete popped; // delete the popped value
--_itemCounter; // decrement counter
}
}
QueueItem.h
#pragma once
#include "Queue.h"
class QueueItem {
public:
QueueItem(const char* pData, int id); // ctor
void setNext(QueueItem* pItem);
QueueItem* getNext() const;
int getId() const;
const char* getData() const;
private:
char _data[30]; // data value (null terminated character string)
const int _itemId; // unique id for item in queue
QueueItem* _pNext; // next item in queue
};
In QueueItem.cpp below, the ctor is not right. The error C++ no instance of overloaded function matches the specified type comes up and I'm not sure why. It seems like the call matches the definition?
QueueItem.cpp
#include "QueueItem.h"
#include <cstring>
#include <string>
QueueItem::QueueItem(char* pData, int id) // ctor
: _itemId{ id } // Initialization list
{
strcpy_s(_data, pData);
_pNext = NULL;
}
void QueueItem::setNext(QueueItem* pItem)
{
_pNext = pItem;
}
QueueItem* QueueItem::getNext() const
{
return _pNext;
}
int QueueItem::getId() const
{
return _itemId;
}
const char* QueueItem::getData() const
{
return _data;
}
main.cpp
#include <iostream>
#include <conio.h>
#include "Queue.h"
using namespace std;
// note - you may need to change the definition of the main function to
// be consistent with what your C++ compiler expects.
int main() {
char anykey;
Queue myQueue;
myQueue.removeItem();
myQueue.addItem("red");
myQueue.addItem("green");
myQueue.addItem("blue");
myQueue.addItem("orange");
myQueue.print(); // print contents of queue (item ID and data)
myQueue.removeItem();
myQueue.removeItem();
myQueue.removeItem();
myQueue.removeItem();
myQueue.print();
myQueue.erase();
myQueue.addItem("olive");
myQueue.addItem("mauve");
myQueue.addItem("purple");
myQueue.print();
myQueue.erase();
myQueue.print();
cout << "Press any key...";
anykey = getch();
return 0;
}

Answer 1

Let's walk through this in order.
Queue.h
#pragma once
#include "QueueItem.h"
You don't actually use the definition of the QueueItem in this header, you only mention pointers to it. To have a pointer to a type (without ever dereferencing it - in the header, that is) - we just need to know the type exists.
So, you can replace the include with the forward declaration
class QueueItem;
And break the cycle between the two header files. (You will now need to include QueueItem.h in Queue.cpp though, because you actually do use it there).
You actually don't need to include Queue.h in QueueItem.h either, because it isn't used at all.
In Queue.cpp below, there are two places where I think the code should either be _pTail->_pNext or _pTail._pNext.
Yep, your first thought was correct.
If it's the ->, then I get C++ member (declared at line 21 of) is inaccessible
The word "inaccessible" tells us that the problem with _pTail->_pNext is that QueueItem::_pNext is declared private. Only methods of the QueueItem class (or friends) itself are allowed to access its private members.
You could add a friend declaration to QueueItem to let Queue have privileged access to its private parts. But, as you already have a public accessor, you can just write _pTail->getNext() instead.
but using the . gives C++ expression must have class type.
This is because only class (and struct, and union) objects have members. You have a pointer to a class object, so -> is the right choice. If it helps to remember, p->member is essentially the same as (*p).member ... it's just nicer to type.
In QueueItem.cpp below, the ctor is not right. The error C++ no instance of overloaded function matches the specified type comes up and I'm not sure why. It seems like the call matches the definition?
These two are not the same:
QueueItem(const char* pData, int id);
QueueItem::QueueItem( char* pData, int id) { ... }
I try to just copy & paste lines like this where possible - there's no benefit in doing more typing, with more opportunity for mistakes, and it's sometimes hard to see these simple errors when you know what you intended to write.