Using nested class, interface, inheritance gives error

[rach]

I just started to learn C++. I copied the following code from a data structure textbook to a ".h" file and couldn't compile it. The code contains three template interfaces. One inherits another. The functions in the interfaces are defined in book, while the nested-class part is added by me. The reason is that if I don't declare a nested class, say Position, how could it be passed as arguments to those defined functions? However, it seems that the compiler doesn't recognize the nested class Position above one level in class hierarchy. The error occurs in the last few lines of the code.

Could you please suggest how to make it work. I really appreciate.
==========================================
The error messages generated by gcc 3.4.4:

Interfaces.h:38: error: expected `,' or `...' before '&' token
Interfaces.h:38: error: ISO C++ forbids declaration of `Position' with no type
Interfaces.h:39: error: expected `,' or `...' before '&' token
Interfaces.h:39: error: ISO C++ forbids declaration of `Position' with no type

==========================================

//interfaces.h
 
#ifndef INTERFACES_H_
#define INTERFACES_H_
#include "RuntimeException.h"
template <typename Object>
class InspectableContainer {
public:
  virtual int size() const = 0;
  virtual bool isEmpty() const = 0;
  class ObjectIterator;
  virtual ObjectIterator elements() const;
  class EmptyContainerException : public RuntimeException {  
  public:
    EmptyContainerException(const string& err) : EmptyContainerException(err) {}
  };
  class BoundaryViolationException : public RuntimeException {  
  public:
    BoundaryViolationException(const string& err) : RuntimeException(err) {}
  };
};
 
template <typename Object>
class InspectablePositionalContainer
  : public InspectableContainer<Object> {
public:
  class Position;                    // node position type
  class PositionIterator;                // position iterator
  virtual PositionIterator positions() const;            // get position iterator
  class InvalidPositionException : public RuntimeException {  
  public:
    InvalidPositionException(const string& err) : RuntimeException(err) {}
  };
};
 
template <typename Object>
class PositionalContainer
  : public InspectablePositionalContainer<Object> {
public:
  virtual void swapElements(const Position& v, const Position& w) = 0; //ERROR OCCURS HERE!!!!!!!!!!!!
  virtual Object& replaceElement(const Position& v, const Object& e) = 0; //ERROR OCCURS HERE!!!!!!!!!!!!
};
#endif
 

[rach]

It turned out that the problem does not lie in nested classes nor interfaces. If I remove
template <typename Object>
and correct one typo in a line, then it compiles.

typo in line 13:
replce
EmptyContainerException(const string& err) : EmptyContainerException(err) by
EmptyContainerException(const string& err) : RuntimeException(err)

I've seen articles that compare template with inheritance. I wonder why I cannot use templates with inheritance relation, that is, replacing class hierarchy by template hierarchy.

[Ganon11]

Glad you figured it out - I'm sorry to say that when I looked at your code, I didn't have a clue as to how to help, so it's good you figured it out on your own.

[rach]

Thank you for looking at my complicated code. (I should have simplified it first.)

Here I summarize my findings.

illegal:
[HTML]
template <typename T>
class A {
public:
typedef int myInt; //member type
class myClass; //member class
virtual void f();
};

/* B inherits from A */
template <typename T>
class B : public A<T> {
public:

virtual void g (const myInt& i, const T& t);
//ERROR - myInt undeclared

virtual void h (const myClass& m);
//ERROR - myClass undeclared
};

/* Concrete implementation of interface A and B */
template <typename T>
class C : public B<T> {
public:

void f() { /* implementation */ }

void g(const myInt& i, const T& t) { /* implementation */ }
//ERROR - myInt undeclared

void h(const myClass& m) { /* implementation */ }
//ERROR - myClass undeclared
};
[/HTML]

error message:


test.h:14: error: expected `,' or `...' before '&' token
test.h:14: error: ISO C++ forbids declaration of `myInt' with no type
test.h:17: error: expected `,' or `...' before '&' token
test.h:17: error: ISO C++ forbids declaration of `myClass' with no type
test.h:28: error: expected `,' or `...' before '&' token
test.h:28: error: ISO C++ forbids declaration of `myInt' with no type
test.h:31: error: expected `,' or `...' before '&' token
test.h:31: error: ISO C++ forbids declaration of `myClass' with no type


After removing template <typename T> and occurrence of T, it becomes legal.

[HTML]
class A {
public:
typedef int myInt; //member type
class myClass; //member class
virtual void f();
};

/* B inherits from A */
class B : public A {
public:
virtual void g (const myInt& i, const double& t); // myInt found
virtual void h (const myClass& m); // myClass found
};

/* Concrete implementation of interface A and B */
class C : public B {
public:
void f() { /* implementation */ }
void g(const myInt& i, const double& t) { /* implementation */ } // myInt found
void h(const myClass& m) { /* implementation */ } // myClass found
};
[/HTML]

[rach]

Once again, I found the problem does not relate to inheritance. Now I really found the solution to my problem. Everytime when you want to access a member type or a member class (nested class) in another class template, you have to use word typename and specify that class template. Even if your current class is derived from that class template, even if that member type or member class you want to access is public, you have to do so.

With normal class hierarchy, you don't need to worry about this.

Using the same example as above, here is an error-free version of the template hierarchy.

[HTML]
template <typename T>
class A {
public:
typedef int myInt; //member type
class myClass; //member class
virtual void f();
};

/* B inherits from A */
template <typename T>
class B : public A<T> {
public:
virtual void g (const typename A<T>::myInt& i, const T& t);
virtual void h (const typename A<T>::myClass& m);
};

/* Concrete implementation of interface A and B */
template <typename T>
class C : public B<T> {
public:
void f() { /* implementation */ }
void g(const typename A<T>::myInt& i, const T& t) { /* implementation */ }
void h(const typename A<T>::myClass& m) { /* implementation */ }
};
[/HTML]

Thank to this reference: http://www.thescripts.com/forum/thread588275.html