Is There A Language That Can Do...

[SMurf]

Hello,

It's late, I'm really tired but there's now something stuck in my head which is nagging me so I think I'd better share it and hopefully get some rest.

I don't have much experience with C++, so I don't know if it does this explicitly. I also don't know what the name of this technique would be, so I can't search for it. Anyway...

Suppose you had a base class like:-

// code might be wrong, again I don't usually do C++
class CBaseClass
{
     static CBaseClass *m_pClassPtr1;
     static CBaseClass *m_pClassPtr2;
     static CBaseClass *m_pClassPtr3;
};

So, the class contains three pointers which can point to instances of the same class.
But what if I then wanted to derive a class from that:-

class CAnotherClass : public CBaseClass
{
    // additonal member variables and methods
};

Instantiating CAnotherClass would give me an object with three pointers to instances of CBaseClass.

What I would like to know is this: is there a way of specifying it so that m_pClassPtr1, 2 and 3 are always pointers to instances of the derived class, whatever that may be? If not in C++ in another language perhaps?

It just crossed my mind that it should certainly be feasible...

[brewbuck]

Maybe this:

template < typename D=void >
class Base;

template < typename D > class PointerTo { public: typedef D *Type; };
template <> class PointerTo< void > { public: typedef Base< void > *Type; };

template < typename D >
class Base
{
protected:
    typename PointerTo< D >::Type ptr1; 
    typename PointerTo< D >::Type ptr2; 
    typename PointerTo< D >::Type ptr3; 

};

class Derived : public Base< Derived >
{
public:
    Derived()
    {
	// Confirm that ptr1 is of type Derived *
	Derived *p = ptr1;
    }
};

int main()
{
    Derived d;
}

The PointerTo<> thing is to allow for Base<> to be used on its own without being derived from (if that's what you want).

[cpjust]

You mean like this?

template <typename T>
class Base
{
protected:
	static T* m_pClassPtr1;
	static T* m_pClassPtr2;
	static T* m_pClassPtr3;
};

class Derived : public Base<Derived>
{
};

[CornedBee]

But then the classes no longer share a common base. Template instantiations are not related.

The request doesn't make sense. These are static members. You say:

Instantiating CAnotherClass would give me an object with three pointers to instances of CBaseClass.

But this is just wrong. Your variables are static members; they exist once in the entire program. If you derive CYetAnotherClass from CBaseClass, which type should these three variables have?

Did you perhaps not mean to make them static?

However, even in this case, what you're asking is against the underlying idea of derivation as it is used in most object-oriented languages, because you try to change the interface of the base class in the derived class.

The only thing you can do is make sure that the variables are only settable within the class itself. Then it can enforce the invariant that the pointers reference objects of the derived class. However, if it is possible for any client of the base class to set the pointers, enforcing this invariant would break the interface.

[SMurf]

Well I picked up the static thing from an example I saw. Again, I don't write C++ so chances are the code that I've written won't make sense. Best to stick to the question. Sorry!

So it can do it through templates then?

[brewbuck]

But then the classes no longer share a common base. Template instantiations are not related.

Then let Base<T> inhererit from SuperBase or something like that. But I missed the static part.

[CornedBee]

So it can do it through templates then?

Kind of, but it's really a solution looking for a problem.

[MK27]

Kind of, but it's really a solution looking for a problem.

Yes, this is a C++ question.




sorry, I had to do that.