"undeclared identifier" is actually declared

Question

I've been getting error C2065s for variables that I've declared in the class header file as public data members, one int and one pointer to that int. The lines of code being flagged as erroneous are only when I use these variables in a function - within the class' constructor, they appear to get through okay.

I'm using Visual Studio 2010 Express to write normal C++ (not Visual C++), and here's the output of the compiler's error log:

1>------ Build started: Project: Project 2, Configuration: Debug Win32 ------
1>  BaseClassWithPointer.cpp
1>d:\libraries\documents\school\advanced c++\project 2\project 2\baseclasswithpointer.cpp(27): error C2065: 'q' : undeclared identifier
1>d:\libraries\documents\school\advanced c++\project 2\project 2\baseclasswithpointer.cpp(27): error C2541: 'delete' : cannot delete objects that are not pointers
1>d:\libraries\documents\school\advanced c++\project 2\project 2\baseclasswithpointer.cpp(32): error C2065: 'num' : undeclared identifier
1>d:\libraries\documents\school\advanced c++\project 2\project 2\baseclasswithpointer.cpp(33): error C2065: 'q' : undeclared identifier
1>d:\libraries\documents\school\advanced c++\project 2\project 2\baseclasswithpointer.cpp(34): error C2065: 'q' : undeclared identifier
1>  Generating Code...
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Finally, here're my code blocks and headers:

BaseClassWithPointer.h

#pragma once
#include <iostream>

using namespace std;

class BaseClassWithPointer
{
public:
    int num;
    int *q;
    BaseClassWithPointer();
    BaseClassWithPointer(int value);
    BaseClassWithPointer(const BaseClassWithPointer& otherObject);
    void destroyPointer();
    virtual void print();
    virtual ~BaseClassWithPointer();                                                        //Destructor is virtual so that derived classes use their own version of the destructor. ~     (2. Inheritance - base class with pointer variables – destructors.)
    const BaseClassWithPointer& operator= (const BaseClassWithPointer &rhs);        //Assignment operator is overloaded to avoid shallow copies of pointers. ~ (3. Inheritance     – base class with pointer variables – assignment operator overloading.)

};

BaseClassWithPointer.cpp

#pragma once
#include "BaseClassWithPointer.h"
#include <iostream>

using namespace std;

BaseClassWithPointer::BaseClassWithPointer()
{
    num = 0;
    q = &num;
}

BaseClassWithPointer::BaseClassWithPointer(int value)
{
    num = value;
    q = &num;
}

BaseClassWithPointer::BaseClassWithPointer(const BaseClassWithPointer& otherObject)
{
    num = otherObject.num;
    q = &num;
}

void destroyPointer()
{
    delete q;
}

void print()
{
    cout << "Num: " << num << endl;
    cout << "Value pointed to by q: " << *q << endl;
    cout << "Address of q: " << q << endl;
}

BaseClassWithPointer::~BaseClassWithPointer()
{
    destroyPointer();
}

const BaseClassWithPointer& BaseClassWithPointer::operator=(const BaseClassWithPointer &rhs)
{
    if (this != &rhs)
    {
        num = rhs.num;
        q = &num;
    }

    return *this;
}

Answer 1

You forgot the Class identifier for your destroyPointer() method. Try

void BaseClassWithPointer::destroyPointer()

instead

Answer 2

This:

void destroyPointer()

...

void print()

Should be

void BaseClassWithPointer::destroyPointer()
{
....
}

void BaseClassWithPointer::print()
{
....
}

etc.

Answer 3

The function destroyPointer() is not part of the class in the cpp file. It should be:

void BaseClassWithPointer::destroyPointer()
{
  delete q;
}

but is:

void destroyPointer()
{
  delete q;
}

This is why it cannot find q