C / C++ / MFC

Arnon A wrote:

cou<<valuedata;< blockquote="">

Shouldn't this be wcout?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"Man who follows car will be exhausted." - Confucius

#include 


class Cloneable
{
public:
    template TYPE* clone() const { return dynamic_cast< TYPE* > ( clone() ); }
    virtual Cloneable* clone() const = 0;
};

// simple template class that defines an interface
// for cloning objects. 
class X : public Cloneable
{
public:
    X(int _y ) : data(_y) { }
    virtual ~X() { /* DO NOTHING */ }
    virtual Cloneable* clone() const { return new X(data); }

protected:
    X() { /* DO NOTHING */ }
    int data;
};

class Y : public X
{
public:
    Y(double f, int y) : X(y), dataf(f) { /* DO NOTHING */  }
    virtual ~Y() { /* DO NOTHING */ }

    virtual Cloneable* clone() const { return new Y(dataf, data); }
protected:
    double dataf;
};

// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

int main(int argc, char* argv[]) 
{        
    X* x = new X(1);
    X* x1 = x->clone();

    Y* y = new Y(2.12, 4);
    Y* y1 = y->clone();

    delete y;
    delete y1;
    delete x;
    delete x1;

    return 0;
}

class Cloneable
{
	public:
		template<class TYPE> TYPE* clone_as() const { return dynamic_cast< TYPE* > ( clone() ); }
		virtual Cloneable* clone() const = 0;
};

int main()
{
    X x( 7 );
    Cloneable *p = &x;

    Y *py = p->clone_as<Y>();
}

class base
{
    public:
		virtual void do_something( int ) { std::cout << "Doing the base class int thing" << std::endl; }
		virtual void do_something( double ) { std::cout << "Doing the base class double thing" << std::endl; }
};

class derived : public base
{
    public:
		virtual void do_something( double )  { std::cout << "Doing the derived class double thing" << std::endl; }
};

int main()
{
	derived d;
	d.do_something( int( 7 ) );
}

class X : public Cloneable
{
      virtual X* clone() const { return new X(data); }
};

class Y : public X
{
      virtual Y* clone() const { return new Y(dataf, data); }
};

int main(int argc, char* argv[]) 
{            
      X* x = new X(1);
      X* x1 = x->clone();

      Y* y = new Y(2.12, 4);
      Y* y1 = y->clone();

      return 0;
}

class ClonerUtility {

 template <class TCoVariantClonable>
 static std::auto_ptr<TCoVariantClonable> CloneAs(const Clonable& pToBeCloned) {
  std::auto_ptr<Clonable> tClone(pToBeCloned.clone());
  if (TCoVariantClonable* tCoVariantClone = 
   dynamic_cast<TCoVariantClonable*>(tClone.get())) {
    tClone.reset(0);
    return std::auto_ptr<TCoVariantClonable>(tCoVariantClone);
  }
  return std::auto_ptr<TCoVariantClonable>();
 }

 template<class TCoVariantClonable>
 static std::auto_ptr<TCoVariantClonable> Clone(const TCoVariantClonable& pToBeCloned) {
  return std::auto_ptr<TCoVariantClonable>(pToBeCloned.clone());
 }
};

//
int main(int argc, char* argv[]) 
{  
 std::auto_ptr<X> tX(new X);
 std::auto_ptr<X> tCloneX = ClonerUtility::Clone(*tX);

 Clonable& tPureClonable = *tCloneX;
 std::auto_ptr<X> tOtherCloneOfX = ClonerUtility::CloneAs<X>(tPureClonable);
}

//    BOOL bCreated = this->CreateEx( 0, cstrWndClassName,
//        L"CMessageOnlyWindow", 0, 0, 0, 0, 0, HWND_MESSAGE, 0 );
    BOOL bCreated = this->CreateEx( 0, cstrWndClassName,
        L"CMessageOnlyWindow", -1000, -1000, 100, 100, 0, HWND_MESSAGE, 0 );