Known Class Issues

The following section describes known class issues and unimplemented or unsupported features.

Class Names
Usually, using elaborate type specifiers ensures the validity of both names when you define a class and a function with the same name in the same scope. However, in the HC(S)08 compilers this type of class name definition causes an error. Example:
```
class C { char c; };


void C(int x) { } 


int x;


void main()


{


      C(x);


------^----------------------- ERROR


}
```
Local classes are unsupported on the HC(S)08 compilers. Example:
```
void f(void)


{


  class C {


    C() { }


  };


}
```

The class member access feature is unsupported. Example:

      class X {


      public:


             enum E { a, b, c };


      } x;


      int type(int ) {return INT;}


      int type(long ) {return LONG;}


      int type(char ) {return CHAR;}


      int type(X::E ) {return ENUMX;}


      type(x.a); 


----------^---------------- Ambiguous parameters type

Nested class declaration is unsupported, although some accesses and calls may succeed when using nested classes.
Nested class depths of ten or more are not supported. Example:
```
struct :: A a;


-------------------^----------------ERROR
```

Function member definitions are not allowed within local class definitions. Example:

void f (){


  class A{


        int g();


---------------^------Illegal local function definition


  };


}

Defining a class within a function template is not allowed. Example:

template <class T> 


struct A {


        void f();


};


template <class T> 


void A<T>::f(){


        class B {


                T x;


        };


-------------^----------------ERROR


}

Unsupported Scope rules for classes
Declaring the name of a class does not ensure that the scope name extends through the declarative regions of classes nested within the first class. Example:
```
struct X4 { 


      enum {i = 4}; 


      struct Y4 { 


            int ar[i];


---------------^-------------------ERROR


      }


}
```
Unimplemented Storage class specifiers
Normally, C++ allows taking the address of an object declared register. Example:
```
register int a;


int* ab = &a;


----------^----- ERROR: Cannot take address of this object
```
The mutable storage class specifier is unsupported.