Member Issues

The following member features are either unimplemented, unsupported, or not functioning correctly in the RS08 compilers.

Pointer to Member
- Global pointer to member initialization is unimplemented. Example:
  Listing: Example - Unsupported Pointer to Member
```
struct S1{};
struct S2 { int member; };

struct S3 : S1, S2 {};

int S3::*pmi = &S3::member;

--------------^--------------- ERROR
```
- Accessing or initializing a class member using a pointer_to_member from that class is unsupported. Example:
  Listing: Example - Unsupported Initialization
```
class X{
public :

   int a;

};

int main(){

   int X::* p0 = &X::a;

   X obj;

   obj.*p0 = -1;

--------^-----------------ERROR:Unrecognized member

}
```
- Constructing an array from a pointer to member of a struct is unsupported. Example:
  Listing: Example - Unsupported Arrary Construction
```
int S::* a0[3];
a0[1] = &S::i

---------^-----------------Failed
```
Static member - When you refer to a static member using the class member access syntax, the object-expression is not evaluated or is evaluated incorrectly. Example:
Listing: Example - Static Member
```
int flag;
struct S {

      static int val(void) { return flag; }

} s;

S* f01() { flag = 101; return &s; }

void main(){

      int g;

      g = f01()->val(); //evaluation failed

}
```
Non-Static Member Functions
- Using non-static data members defined directly in their overlying class in non-static member functions is unsupported. Example:
  Listing: Example - Unsupported Non-Static Member Functions
```
class X {
      int var;

public:

      X() : var(1) {}

      int mem_func();

} x;

int X::mem_func(){

      return var; //returned value should be 1

}
```
- A non-static data member/member function name should refer to the object for which it was called. However, in the RS08 compiler, it does not. Example:
  Listing: Example - Unsupported Non-Static Data Member
```
class X {
public:

     int  m;

     X(int a) : m(a) {}

}

X obj = 2;

 int a  = obj.m; //should be 2 (but is not)
```

Member Access Control

Accessing a protected member of a base class using a friend function of the derived class is unsupported. Example:
Listing: Example - Accessing a protected Member Using a Friend Function
```
class A{
protected:

      int i;

};

class B:public A{

      friend int f(B* p){return p->i};

} ;
```

Specifying a private nested type as the return type of a member function of the same class or a derived class is unsupported. Example:

Listing: Example - Specifying a Private Nested Type as the Return Type



class A {
protected:

      typedef int nested_type;

      nested_type func_A(void);

};

Class B: public A{

      nested_type func_B(void);

};

A::nested_type A::func_A(void) { return m; }

B:: nested_type B::func_B(void) { return m; }

^------------------------------------ERROR: Not allowed

Accessing a protected member is unsupported. Example:

Listing: Example - Accessing a Protected Member


class B {

protected:

      int i;

}; 

class C : private B {

      friend void f(void);

};

void f(void) { (void) &C::i;}

-------------------------^------ERROR: Member cannot be accessed

Access declaration
Base class member access modification is unimplemented in the following case:

Listing: Example - Access Modification of a Base Class Member
```
class A{
public:

      int z;

};

class B: public A{

public:

      A::z;

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

};
```