Member Issues

The following member features are either unimplemented, unsupported, or not functioning correctly in the HC(S)08 compilers.

• Pointer to Member
  • Global pointer to member initialization is unimplemented. Example:

    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:

    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:

    int S::* a0[3];
    a0[1] = &S::i
    ---------^-----------------Failed

• Static member - When you refer a static member using the class member access syntax, the object-expression is not evaluated or is evaluated incorrectly. Example:

  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:

    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 HC(S)08 compiler, it does not. Example:

    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:

    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:

    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:

    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:

    class A{
    public:
          int z;
    };
    class B: public A{
    public:
          A::z;
    ---------^------------ERROR
    };