inheritance

[mickey]

hi, I 've got a simple problem with subclass and method (I'll leave out some keywords to go direct to problem...).This isn't real C++ but the concept shouldn't change...

abstract baseClass {
   List <baseClass> list = new List<BaseClass>();
   List<Two> list_two=new List<Two>();
 
   virtual add(BaseClass class) {
       list.Add(class);
       if (class.Type is "Two" also do.......)
             list_two.Add(class); //here error, because class hasn't same type of list_two...
  }
}
 
 
class One : baseClass {
    override void add(BaseClass class) {
              // do something
              base.add(class);
   }
}
 
 
class Two : baseClass{
         //constructor and the rest
}
 
main {
   Two two;
   One one;
   one.add(new two() );
}

abstract baseClass {
   List <baseClass> list = new List<BaseClass>();
   List<Two> list_two=new List<Two>();

   virtual add(BaseClass class) {
       list.Add(class);
       if (class.Type is "Two" also do.......)
             list_two.Add(class); //here error, because class hasn't same type of list_two...
  }
}


class One : baseClass {
    override void add(BaseClass class) {
              // do something
              base.add(class);
   }
}


class Two : baseClass{
         //constructor and the rest
}

main {
   Two two;
   One one;
   one.add(new two() );
}

To copy to clipboard, switch view to plain text mode 

Must I have refactor the classes or how can I do this things?
thanks...

[Michiel]

If you've already established that the type of the class is Two, you can just do a static cast.

list_two.Add(static_cast<Two>(class));

[wysota]

What happens if you make the list store pointers?

[Michiel]

I was assuming that the list was storing pointers anyway. A static cast will work. But, like I said, only if you're already sure 'class' is pointing to a 'Two' instance.

[mickey]

HI,
1. and If list_two contain pointer????
2. I'm wondering if the control of the type class and the list_two.add was better put it inside the override member instead of virtual..
Base class can point to derived class; but if (and will be so) Two has some field more than base class, what happen to this fields in derived -> base convertion?
if I have:

void doSOmething(BaseClass base) {
  base.field1; // ok field1 was in the base
  base.field2 //base hasn't field2: it can't used it here.
  base.fieldN;
}
//main 
 Two two;
 doSomething(two);

void doSOmething(BaseClass base) {
  base.field1; // ok field1 was in the base
  base.field2 //base hasn't field2: it can't used it here.
  base.fieldN;
}
//main 
 Two two;
 doSomething(two);

To copy to clipboard, switch view to plain text mode 

Is in this way that work the things, please?
thanks.

[Michiel]

I'm sorry, but your English is a bit unclear (and one question mark is really enough).

Would you rephrase the question, and give us an example in actual C++?

[mickey]

Hi, but this isn't c++......However:

abstract baseClass {
   List <baseClass> list = new List<BaseClass>();
   List<Two> list_two=new List<Two>();
 
   virtual add(BaseClass class) {
       list.Add(class);
 
       if (class.Type is "Two" )   list_two.Add((Two) class); 
      /* is correct put this above here? Maybe Was better put it in [1] ? */
       class.value = 10; //does it make sense???
  }
}
 
class One : baseClass {
    One (){}
    override void add(BaseClass class) {
              // ----------- [1]
              // do something
              base.add(class);
   }
}
 
 
class Two : baseClass{
         Two() {}
         //constructor and the rest
         int value;
 
}
 
main {
   Two two;
   One one;
   one.add(new two() ); // here the object two is "converted" to its base class; the base   
           //class hasn't value field: is this "convertion" and the "cast" like you have advice,  
           //could have any problem ???
}

abstract baseClass {
   List <baseClass> list = new List<BaseClass>();
   List<Two> list_two=new List<Two>();

   virtual add(BaseClass class) {
       list.Add(class);

       if (class.Type is "Two" )   list_two.Add((Two) class); 
      /* is correct put this above here? Maybe Was better put it in [1] ? */
       class.value = 10; //does it make sense???
  }
}

class One : baseClass {
    One (){}
    override void add(BaseClass class) {
              // ----------- [1]
              // do something
              base.add(class);
   }
}


class Two : baseClass{
         Two() {}
         //constructor and the rest
         int value;
         
}

main {
   Two two;
   One one;
   one.add(new two() ); // here the object two is "converted" to its base class; the base   
           //class hasn't value field: is this "convertion" and the "cast" like you have advice,  
           //could have any problem ???
}

To copy to clipboard, switch view to plain text mode 

[Gopala Krishna]

If your problem is only with the conversion of Base* to Two* when the argument is genuinely Two* type, then its absolutely safe to use static cast to convert Base* to Two*.

[Gopala Krishna]

Well what i said above is not true in all cases. I'll explain it through code

#include <iostream>
 
using namespace std;
class Derived;
class Base
{
	public:
	virtual ~Base() {}
 
	virtual void add(Base *b)
	{
		//assume i somehow determine b is actually Derived* type
               Derived *d = static_cast<Derived*)(b);
               // But still this doesn't compile at all!!
	}
        void anotherFunc(Base *b);
};
 
class Derived : public Base
{
	public:
	Derived() { add(this); }
 
	void sayHello()
	{
		cout << "Hello" << endl;
	}
};
 
void Base::anotherFunc(Base *b)
{
       //assume i somehow determine b is actually Derived* type
               Derived *d = static_cast<Derived*)(b);
     //This succeeds!!!!
}
int main()
{
	Derived *d;
	Base *b = new Base;
	d = static_cast<Derived*>(b);
        // This too succeeds
	int c;
	cin >> c;
	return 0;
}

#include <iostream>

using namespace std;
class Derived;
class Base
{
	public:
	virtual ~Base() {}
	
	virtual void add(Base *b)
	{
		//assume i somehow determine b is actually Derived* type
               Derived *d = static_cast<Derived*)(b);
               // But still this doesn't compile at all!!
	}
        void anotherFunc(Base *b);
};

class Derived : public Base
{
	public:
	Derived() { add(this); }
	
	void sayHello()
	{
		cout << "Hello" << endl;
	}
};

void Base::anotherFunc(Base *b)
{
       //assume i somehow determine b is actually Derived* type
               Derived *d = static_cast<Derived*)(b);
     //This succeeds!!!!
}
int main()
{
	Derived *d;
	Base *b = new Base;
	d = static_cast<Derived*>(b);
        // This too succeeds
	int c;
	cin >> c;
	return 0;
}

To copy to clipboard, switch view to plain text mode 

So basically for the cast to work the compiler should have the definition of class type being casted to at the place of casting. That is to say if the compiler doesn't choke on cast and if you somehow determine that given class is Derived type you can use static_cast

[wysota]

I don't think we'll solve the issue with pseudo code. Logically according to inheritance paradigm the code is correct and should work without any casts. So if something doesn't work, I suggest you show us the actual code.

[mickey]

It'sn't c++; it's C# (apart the main); But it works now; what I was wondering is if it's a good use of inheritance or other.....
thanks

[wysota]

Yes, it's a proper use of inheritance.