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 RS08 compilers this type of class name definition causes an error. Example:

Listing: Example - Unsupported Class Name Definition
```
class C { char c; };
void C(int x) { } 

int x;

void main()

{

      C(x);

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

}
```
Local classes are unsupported on the RS08 compilers. Example:
Listing: Example - Unsupported Local Class
```
void f(void)
{

  class C {

    C() { }

  };

}
```

The class member access feature is unsupported. Example:

Listing: Example - Unsupported Class Member Access Feature



      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:
Listing: Example - Unsupported Nested Class
```
      struct :: A a;
-------------------^----------------ERROR
```
Function member definitions are not allowed within local class definitions. Example:
Listing: Example - Unsupported Member Function Definition
```
void f (){
  class A{

        int g();

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

  };

}
```

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

Listing: Example - Unsupported Definition of Class within a Function Template



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:

Listing: Example - Unsupported Scope
```
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:

Listing: Example - Unimplemented Storage Class Specifiers
```
      register int a;
      int* ab = &a;

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