r3dux.org

// C++ FAQS by Cline & Lowom
// FAQ 162 - What is a down-cast?
// Answer: Trouble.
 
#include <iostream>
 
using namespace std;
 
class Asset
{
	public:
		virtual ~Asset() { }
		virtual bool isLiquidatable() const { return false; } // BAD-FORM: Capability query
};
 
class LiquidAsset : public Asset
{
	protected:
		int mValue;
 
	public:
		LiquidAsset(int value = 100) : mValue(value) { }
 
		int getValue() const { return mValue; }
 
		void setValue(int theValue) { mValue = theValue; }
 
		virtual bool isLiquidatable() const { return true; } // BAD-FORM: Capability query
};
 
// Userland function to liquidate an asset (if it can)
int tryToLiquidate(Asset &asset)
{
	int value;
 
	if ( asset.isLiquidatable() )                     // BAD-FORM: Finds code using code
	{
		value = ((LiquidAsset&)asset).getValue(); // BAD-FORM: Down-cast
 
		((LiquidAsset&)asset).setValue(0);        // BAD-FORM: Down-cast
 
		cout << "Liquidated $" << value << endl;
	}
	else
	{
		value = 0;
		cout << "Sorry, couldn't liquidate this asset.\n";
	}
 
	return value;
}
 
int main()
{
    Asset       a;
    LiquidAsset b;
 
    tryToLiquidate(a);
    tryToLiquidate(b);
 
    return 0;
}

// C++ FAQS by Cline & Lowom
// FAQ 163 - What is an alternative to using down-casts?
// Answer: An if/down-cast pair can often be replaced by a virtual function call. The key
// insight is to move the -context- of the capability query from the user's code into the
// virtual function; don't just move the primitive query used in the user's if statements.
 
#include <iostream>
using namespace std;
 
class Asset
{
	public:
		virtual ~Asset() { }
 
		virtual int tryToLiquidate()
		{
			cout << "Sorry, couldn't liquidate this asset.\n";
			return 0;
		}
};
 
class LiquidAsset : public Asset
{
	protected:
		int mValue;
 
	public:
		LiquidAsset(int value = 100) : mValue(value) { }
 
		int getValue() const { return mValue; }
 
		void setValue(int theValue) { mValue = theValue; }
 
		virtual int tryToLiquidate()
		{
			int value = mValue;
 
			mValue = 0;
 
			cout << "Liquidated $" << value << endl;
 
			return value;
		}
};
 
int main()
{
    Asset       a;
    LiquidAsset b;
 
    a.tryToLiquidate();
    b.tryToLiquidate();
 
    return 0;
}

// Book: C++ FAQs by Cline & Lomow
// FAQ 136 & 137 - Is array-of Derived a kind-of array-of Base?
// Answer: NO!
 
#include <iostream>
using namespace std;
 
class Base
{
	protected:
		int i;
 
	public:
		Base() : i(42*42)      { }
		virtual ~Base()        { }
		virtual void service() { cout << "Base::service() called.\n" << flush; }
};
 
class Derived : public Base
{
	protected:
		// Add some extra things so that an object of type Derived is a different
		// size to an object of type Base
		int j;
		float k;
		unsigned long l;
 
	public:
		Derived() : Base(), j(42*42*42) { }
		virtual void service()          { cout << "Derived::service() called.\n" << flush; }
};
 
// Userland function
void useSubscript(Base *b)
{
	cout << "b[0].service(): " << flush; b[0].service();
	cout << "b[1].service(): " << flush; b[1].service(); // BOOM! Segfault!
 
	// This fails because the size of Base and the size of Derived are different:
	// "The fundamental problem is that a pointer to the first of an array-of-things
	// has exactly the same type as a pointer to a single thing. This was inherited
	// from C."
	//
	// In essence, as we're passing in Base pointers, in this case Base moves from
	// element to element in 16 byte intervals, but we actually provided an array
	// of Derived objects, which have a size of 32 bytes each, so b[1] starts
	// at b[0]+16, which is really only half-way through our first Derived element d[0]!
	//
	// The way to do this properly is to use a templatised container class instead.
	// If you tried to pass Array<Derived> as Array<Base> this would be caught at compile time.
}
 
int main()
{
    Derived d[10];
 
    cout << "Base has a size of   : " << sizeof(Base)    << " bytes." << endl;         // 16 bytes
    cout << "Derived has a size of: " << sizeof(Derived) << " bytes." << endl << endl; // 32 bytes
 
    useSubscript(d);
 
    return 0;
}

var greetTimer:Timer = new Timer(3000, 1);
greetTimer.addEventListener(TimerEvent.TIMER, greet);
greetTimer.start();
 
function greet(e:TimerEvent):void
{
	trace("Hello!");
}

var name:String = "Bob";
 
var greetTimer:Timer = new Timer(3000);
greetTimer.addEventListener(TimerEvent.TIMER, greet(name));
greetTimer.start();
 
function greet(e:TimerEvent, theName:String):void
{
	trace("Hello, " + theName + "!");
}

greetTimer.addEventListener(TimerEvent.TIMER, greet, name);

package
{
	// Import required libraries
	import flash.utils.Timer;
 
	public class cTimer extends Timer
	{
		// Create a property for our cTimer class which can be used to store a String
		public var firstName:String;
 
		// Constructor function
		public function cTimer(theDelay:Number, theRepeatCount:int, theFirstName:String):void
		{
			// Create a normal timer using the Timer class' constructor
			super(theDelay, theRepeatCount);
 
			// Set our firstName property to what was passed to our cTimer constructor
			this.firstName = theFirstName;
 
		} // End of constructor
 
	} // End of class
 
} // End of package

// Import our custom timer class for use
import cTimer;
 
var greetTimer:Timer = new cTimer(3000, 1, "Bob");
greetTimer.addEventListener(TimerEvent.TIMER, greet);
greetTimer.start();
 
function greet(e:TimerEvent):void
{
	trace("Hello, " + e.currentTarget.firstName + "!");
}

package
{
	// Import required libraries
	import flash.utils.Timer;
	import flash.display.DisplayObject;
 
	public class cTimer extends Timer
	{
		// Create a property for our cTimer class which can be used to store a DisplayObject
		public var timerTarget:DisplayObject;
 
		// Constructor function
		public function cTimer(theDelay:Number, theRepeatCount:int, theTimerTarget:DisplayObject):void
		{
			// Create a normal timer using the Timer class' constructor
			super(theDelay, theRepeatCount);
 
			// Set our timerTarget to what was passed to our cTimer constructor
			this.timerTarget = theTimerTarget;
 
		} // End of constructor
 
	} // End of class
 
} // End of package

// Import our custom timer class for use
import cTimer;
 
// Create a simple circle centered on the stage and fully transparent
var circle_mc:Circle = new Circle();
circle_mc.x = 275;
circle_mc.y = 200;
circle_mc.alpha = 0;
addChild(circle_mc);
 
// Create a custom timer which does everything a timer does, but also stores a DisplayObject
var circleFadeInTimer:cTimer = new cTimer(2000, 1, circle_mc);
circleFadeInTimer.addEventListener(TimerEvent.TIMER, fadeIn);
circleFadeInTimer.start();
 
// Function to make the circle visible
function fadeIn(e:TimerEvent):void
{
	// Using our timerTarget property of our custom timer class (cTimer) modify the DisplayObject
	e.currentTarget.timerTarget.alpha = 1;	
}