help w/template iters

**sh3rpa** · 10-05-2007

thx dudes & dudettes!

**sh3rpa** · 10-05-2007

Oh BTW, I feel retarded about the whole *instance* thing.

I think you were saying this is bad:

Code:

class myClass
{
    aNotherClass x;

    /*  OR  */

   aNotherClass * x = new aNotherClass();
};

right?

Because I knew that, the terminology just confused me a bit.

Which brings me to another question:

When you use *inheritance* does that create an *instance* of the base class? I'm pretty sure it does because if you have the constructors of your parent & child classes print a simple message, you see both.

I know some people avoid inheritance at all costs, is this the reason why they do that?

**laserlight** · 10-05-2007

I think you were saying this is bad:

No, matsp is not saying that that is bad. Member variables, and members in general, have their uses, i.e. "what's necessary to solve the problem and nothing more". matsp was criticising the use of member variables where local variables are more appropriate.

When you use *inheritance* does that create an *instance* of the base class?

No, it just creates a class hierarchy. I guess that you are actually asking: are instances of a derived class also instances of its base class? The answer would then be yes, as it is the basis for runtime polymorphism.

**CornedBee** · 10-05-2007

I know some people avoid inheritance at all costs

Poor, misguided souls.

**matsp** · 10-05-2007

The thing I'm saying is bad is:

Code:

class x {
  vector<int> v;
  vector<int>::iterator i;
};

The iterator should not be PART OF THE CLASS.

It is fine to have one class as a member inside another one, likewise, if it's meaningfull to solve the problem, have pointer(s) to class instances.

What you shouldn't do is stuff all sorts of things inside the class that doesn't belong in the class -such as iterators that are just used inside one function, or integer variables used to loop through some fixed lenght array, temporary results of calculations, or some such.

--
Mats

**sh3rpa** · 10-05-2007

Originally Posted by laserlight

I guess that you are actually asking: are instances of a derived class also instances of its base class? The answer would then be yes, as it is the basis for runtime polymorphism.

ok, so that allows me to do fun stuff like:

Code:

Base *ptr;
Child *ptr2 = (Child*)ptr;

**matsp** · 10-05-2007

Originally Posted by sh3rpa

ok, so that allows me to do fun stuff like:

Code:

Base *ptr;
Child *ptr2 = (Child*)ptr;

Yes, but more:

Code:

Base *ptr;
ptr = new Child;

--
Mats

**anon** · 10-05-2007

C-style casts shouldn't be used in such cases. A base pointer is not neccessarily a valid child pointer. You'll need dynamic_cast which returns 0, if the pointer cannot be cast.

Children can always be up-cast towards base, but base pointer cannot be down-cast to a child pointer unless the base pointer is actually pointing to a particular child (or any class down the hierarchy after the child).

**sh3rpa** · 10-05-2007

should dynamic_cast be used in BOTH cases then? i know in most C++ books, they'll tell you to use daynamic_cast. I was just being sloppy.

**laserlight** · 10-05-2007

should dynamic_cast be used in BOTH cases then?

No. As anon pointed out, "children can always be up-cast towards base".

**Daved** · 10-05-2007

No cast is necessary for assigning a child pointer/reference to a parent pointer/reference:

Code:

Derived* derived_ptr = new Derived;
Base* base_ptr = derived_ptr;

Derived derived_obj;
Base& base_ref = derived_obj;

A dynamic_cast can be used when going the other way if you want to verify that the conversion is valid:

Code:

Base* base_ptr = new Derived;
Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
if (derived_ptr == 0)
  // cast failed

Derived derived_obj;
Base& base_ref = derived_obj;
try
{
  Derived& derived_ref = dynamic_cast<Derived&>(base_ref);
}
catch (std::bad_cast&)
{
  // cast failed
}

If you know that the conversion will succeed through some other logic, then use a static_cast.

Code:

Base* base_ptr = new Derived;
Derived* derived_ptr = static_cast<Derived*>(base_ptr);
// cast should never fail

Derived derived_obj;
Base& base_ref = derived_obj;
Derived& derived_ref = static_cast<Derived&>(base_ref);
// cast should never fail

Thread: help w/template iters

Thread Tools

Search Thread

Display