title: <Method> is not a member of <Class>
body: <p>This is pretty basic stuff I have done before, but I don't understand why I'm having an issue now. I'm creating an object 'foo' for easy interfacing with iostream activity to and from files.</p>
  
  <p>I have built almost the entire project with no issues until today when I added a couple of methods that seem to have issues being found within the context of the definition file.</p>
  
  <p>foo.h:</p>
  
  <pre><code>    #ifndef FOO_H
      #define FOO_H
  
      #include &lt;string&gt;
      #include &lt;fstream&gt;
      #include &lt;vector&gt;
  
      using std::string;
      using std::fstream;
      using std::vector;
  
      namespace FileSys
      {
          class foo
          {
          public:
              foo();
              /**
               * Attempts to open a file from directory dir
               * @param dir
               *              The path of the file to be opened
               */
              foo( string dir );
              /**
               * Attempts to find a directory using the parent file's path as the root directory and extending the directory by the child string
               * If child is null, the foo is replicated. Fails when parent.isDirectory() returns false.
               * @param parent
               *              The parent file to be used as the root path
               * @param child
               *              The child path to be used for extending the parent path
               */
              foo( foo &amp;parent, string child );
              /**
               * Attempts to find a directory using the parent path as the root directory and extending the directory by the child string
               * If child is null, the foo is created with the parent path as the full path.
               * @param parent
               *              The parent path to be used as the root path
               * @param child
               *              The child path to be used for extending the parent path
               */
              foo( string parent, string child );
              /**
               * Attempts to clone reference to a previously existing foo file
               * @param file
               *              The file to be cloned
               */
              foo( foo &amp;file );
  
              /**
               * Returns the working directory of this file
               */
              string getDir();
  
              /**
               * Writes the content supplied to the file, overwriting any existing data
               */
              bool writeTrunc( string content );
  
              /**
               * Writes the content supplied to the file, appending it to the end of the file
               */
              bool writeApp( string content );
  
              /**
               * Concatenates two files together. No implementation yet.
               */
              bool concatFiles( foo file1, foo file2 );
  
              /**
               * Reads from file
               *
               * @param length
               *              How many bytes will be retrieved from the file
               */
              string read( int length );
  
              /**
               * Reads from file
               *
               * @param length
               *              How many bytes will be retrieved from the file
               *
               * @param position
               *              Position to start reading from
               */
              string read( int length, int position );
  
              /**
               * Returns everything from the file
               */
              string readWholeFile();
  
              /**
               * Returns true if the file exists
               */
              bool exists();
  
              /**
               * Attempts to delete the current file
               * @return Returns true if successful and false otherwise
               *              The path of the file to be opened
               */
              bool deleteFile();
  
              /**
               * Returns true if this foo is a directory, rather than a file
               */
              bool isDirectory();
  
              /**
               * Returns the absolute path of the foo
               */
              string getAbsolutePath();
  
              /**
               * Returns the parent directory of this foo
               */
              foo getParentFile();
  
              /**
               * Creates all non-existent folders in mPath, creating the directory for this foo.
               */
              bool mkdirs();
  
              /**
               * Clean the file attributes
               */ 
              bool cleanFile();
  
              /**
               * Returns a list of all the directories and files contained within this directory 
               */
              vector&lt;foo&gt; list();
  
              /**
               * Deletes the file or directory from the file system
               */
              bool destroy();
  
              /**
               * Overrides the '=' operator to perform an assignment properly
               */
              foo&amp; operator=(foo &amp;file);
  
              /**
               * Overrides the '==' operator to perform an equality comparison on two foo
               */
              bool operator==(foo &amp;file);
  
              /**
               * Overrides the '!=' operator to perform an inequality comparison on two foo
               */
              bool operator!=(foo &amp;file);
  
              ~foo();
          protected:
          private:
  
              string mPath;
              fstream mFile;
              bool mExists;
              bool mIsFile;
  
              /**
               * Opens the file for operation
               * 
               * @param openMode
               *          The mode the file should be opened in. Use ios::openmode modes to determine the open mode.
               *
               * @return Returns true if successfully opened and false if failed
               */
              bool openFile( int openMode );
  
              /**
               * Indicates whether this foo is a file or a directory
               * Returns true if a file and false if a directory.
               */
              bool isFile();
  
              /**
               * Checks to see if the directory exists and attempts to create it if its parents exist
               *
               * @param dir
               *          The directory to be created
               *
               * @return Returns true if successful
               */
              bool mkdirs( foo dir );
      };
  
  }
  
  #endif // foo_H
  </code></pre>
  
  <p>foo.cpp:</p>
  
  <pre><code>    #include "foo.h"
  
      #include &lt;string&gt;
      #include &lt;fstream&gt;
      #include &lt;vector&gt;
      #include &lt;errno.h&gt;
      #ifdef HAVE_UNISTD_H
      #include &lt;unistd.h&gt;
      #endif /* HAVE_UNISTD_H */
      #include &lt;sys/stat.h&gt;
  
      using std::string;
      using std::fstream;
      using std::vector;
  
      #ifdef _WIN32
      #include &lt;direct.h&gt;
      using namespace std;
      #define mkdir(path,mode) _mkdir(path)
      #define getcwd _getcwd
      #endif
  
      #define ROOT_WORKING_DIRECTORY "SomeDir"
  
      namespace FileSys
      {
          ////////////////////////////////////////////
          // Ctors
          ////////////////////////////////////////////
          foo::foo()
          { /*implementation*/ }
  
          foo::foo( string dir )
          { /*implementation*/ }
  
          foo::foo( foo &amp;file )
          { /*implementation*/ }
  
          foo::foo( foo &amp;parent, string child )
          { /*implementation*/ }
  
          foo::foo( string parent, string child )
          { /*implementation*/ }
  
          ////////////////////////////////////////////
          // Public methods
          ////////////////////////////////////////////
          string foo::getDir()
          { /*implementation*/ }
  
          bool foo::deleteFile()
          { /*implementation*/ }
  
          bool foo::exists()
          { /*implementation*/ }
  
          bool foo::writeApp( string content )
          { /*implementation*/ }
  
          bool foo::writeTrunc( string content )
          { /*implementation*/ }
  
          string foo::read( int length )
          { /*implementation*/ }
  
          string foo::read( int length, int position )
          { /*implementation*/ }
  
          string foo::readWholeFile()
          { /*implementation*/ }
  
          bool foo::isDirectory()
          { /*implementation*/ }
  
          string foo::getAbsolutePath()
          { /*implementation*/ }
  
          foo foo::getParentFile()
          { /*implementation*/ }
  
          bool foo::mkdirs()
          { /*implementation*/ }
  
          foo&amp; foo::operator=(foo &amp;file)
          { /*implementation*/ }
  
          bool foo::operator==(foo &amp;file)  //err 2039: 'operator==' is not a member of foo
          { /*implementation*/ }
  
          bool foo::operator!=(foo &amp;file)  //err 2039: 'operator!=' is not a member of foo
          { /*implementation*/ }
  
          bool foo::cleanFile()
          { /*implementation*/ }
  
          vector&lt;foo&gt; foo::list()  //err 2039: 'list' is not a member of foo
          { /*implementation*/ }
  
          bool foo::destroy()  //err 2039: 'destroy' is not a member of foo
          { /*implementation*/ }
  
          ////////////////////////////////////////////
          // Private methods
          ////////////////////////////////////////////
          bool foo::openFile( int openMode )
          { /*implementation*/ }
  
          bool foo::isFile()
          { /*implementation*/ }
  
          bool foo::mkdirs( foo dir )
          { /*implementation*/ }
  
          ////////////////////////////////////////////
          // Dtors
          ////////////////////////////////////////////
          foo::~foo()
          { /*implementation*/ }
  
      }
  </code></pre>
  
  <p>Any clues as to what I've done to create this issue?</p>
  
  <p>Edit: I included the real code with only the class signature changed and the implementations removed. I have triple checked the syntax to ensure that I haven't misspelled the class name in the scope resolution of the methods that aren't working.</p>