class Item{public:    virtual UseItem()    {        cout << "You eat/drink the item." << endl;    }};class Weapon : public Item{public:    virtual UseItem()    {        cout << "You wield the weapon." << endl;    }};Now, if I create an object of type "Weapon" such as the line below and call UseItem it calls the function as normal.// This does exactly what you expectWeapon* pWeapon = new Weapon();pWeapon->UseItem();Where it's different, is if I've got a pointer which claims to be a different interface than the object actually is..for exampleItem* pItem = pWeapon; // assign the weapon to the item pointer, since a weapon IS-A item this is perfectly legal.// Here's the magic of virtual functions.  When I call UseItem on this pointer// i see "You wield the weapon."  because pItem ACTUALLY points to a weapon,// and since the function is virtual, the correct call is resolved.// if the function UseItem had not been virtual, it would not have been able// to resolve the call to the correct type, and I would have seen // "You eat/drink the item." instead.pItem->UseItem(); 

Quote:

Original post by Deyja I have never seen a class that is both nested in and derived from the same class.

struct Array { virtual int Size(); ... struct Static; struct Dynamic;}; //You can declare these inside the class, but I preferred to declare 'em outstruct Array::Static : public Array { ... }struct Array::Dynamic : public Array { ... }

Quote:

8) What does declaring a method as virtual do? A) It allows pointers to base classes to be assigned to derived class objects.

class Base { public: virtual void foo(){} };class Example1 : public Base { virtual void foo(){} };class Example2 : public Base { virtual void foo(){} };class Example3 : public Example2 { /* doesnt reimplement foo */ };void bar( Base &b ) {   b.foo();}int main() {    Base b;    Example1 one;    Example2 two;     Example3 three;    bar(b);     // calls Base::foo    bar(one);   // calls Example1::foo    bar(two);   // calls Example2::foo    bar(three); // calls Example2::foo, Example 3 doesn't reimplement foo}

Quote:

9) Can virtual functions be used on non-pointer, non-reference variables? A) No, doing this will slice the objects v-pointer intoo calling only the base class it's constructor, not it's derived constructor(s).

class Base { };class Derived : public Base { };void foo() {   Derived d;   Base b = d; // oh no, slicing!}

Quote:

Original post by rip-off Not quite. Virtual functions work fine on non-pointer/reference variables. What you describe occurs when you assign a derived object to an object of its base class:

Quote:

Page 404: Functions in the base class can be overridden in the derived class. If the base class functions are virtual, and if the object is accessed by pointer or reference, the derived class's functions will be invoked, based on the runtime type of the object pointed to.

Quote:

Original post by J0Be Hi rip-off

Quote:

In the book it clearly is stated and I quote: Quote: Page 404: Functions in the base class can be overridden in the derived class. If the base class functions are virtual, and if the object is accessed by pointer or reference, the derived class's functions will be invoked, based on the runtime type of the object pointed to. That does mean you can't use objects by value to get the same effect right? Doing this will invoke the base constructor and not the derived constructor as you actually desire? So, you are slicing, atleast, that's how I see it.

class Base {   public:      virtual void foo(){}};class Derived : public Base {   public:      virtual void foo(){}};void bar( Base base ) {    base.foo();}int main() {    Base base;    Derived derived;    derived.foo(); // no slicing, compiler calls Derived::foo    bar(base);    bar(derived); // slice occurs here!                  // also compiler will call Base::foo on the sliced object in bar...}

Quote:

Original post by rip-off Unless of course you are talking about the accidental slicing of an object passed as a parameter( as I alluded to at the end of my last post)

Quote:

Remember the question though, which was "will virtual functions work on value objects". The answer is that functions declared virtual can be called on a value object and it will work, however the decision as to which function will be run is made at compile time, not runtime.

Quote:

2) Show the declaration of a class Square, which derives from Rectangle, which in turn derives from Shape. 3) If, in Exercise 2, Shape takes no parameters, Rectangle takes two (length and width), but Square takes only one (length), show the constructor initialization for Square.

#include <iostream>class Shape{public:	Shape() {}	 ~Shape() {}};class Rectangle : public Shape{public:	Rectangle() {}	 ~Rectangle() {}};class Square : public Rectangle{public:	Square() {}	 ~Square() {}};int main(){	return 0;}

#include <iostream>class Shape{public:	Shape() {}	 ~Shape() {}};class Rectangle : public Shape{public:	Rectangle() {}	Rectangle(int length, int width);	 ~Rectangle() {}protected:	int m_Length;	int m_Width;};Rectangle::Rectangle(int length, int width) : m_Length(length), m_Width(width) {}class Square : public Rectangle{public:	Square() {}	Square(int length);	 ~Square() {}};Square::Square(int length) : Rectangle(length, width) {}int main(){	return 0;}