template<typename GenType>
class Character
{
/* class stuff... no reference to GenType... or did I miss that?*/
};

class NPC: public Character<NPC>
{
};

#define GenType NPC

class Character
{
 GenType *SomeVar;
 void DoSomething(GenType param);
};

class NPC : public Character
{
};

template <class GenType>
class Character
{
public:
 GenType *SomeVar;
 void DoSomething(GenType param);
};

class NPC : public Character<NPC>
{
};

class NPC
{
 NPC *SomeVar;
 void DoSomething(GenType param);
};

quote:

---

Original post by duke
The author is mis-using reinterpret_cast in this article. The correct method is to use static_cast for all the examples he gave. Other than that it is a good article on template programming but the specific examples are a bit contrived, but I suppose they have to be in order to get the point across without putting up an entire program.

---

quote:

---

Original post by duke
The author is mis-using reinterpret_cast in this article. The correct method is to use static_cast for all the examples he gave.

---

quote:

---

Other than that it is a good article on template programming but the specific examples are a bit contrived, but I suppose they have to be in order to get the point across without putting up an entire program.

---

quote:

---

Original text from l'Artical
...most compilers require templates to be declared inline. This means that all your templated functions will have to go in the header, which can make your code less tidy.

---

quote:

---

Original post by superpig
One solution would be to derive the templated base class itself from *another* base class which is non-parametrised - CPhysicsEntity. I could then store a list of CPhysicsEntity* with no problem. However , to get at the actual object I then need some virtual functions... which defeats the point of the system in the first place

---

class A {
    virtual void Foo_Aux();
    void Foo() { Foo_Aux(); }
};

template<typename AType>
class A_Aux : public A
{
    void Foo() { 
        static_cast<AType &>(*this).Bar(); 
        static_cast<AType &>(*this).Baz(); 
    }

    virtual void Foo_Aux() { Foo(); }
};

class B : public A_Aux<B>
{
    void Bar() { ... }
    void Baz() { ... }
};

quote:

---

I guess for a fully flexible system it's impossible to avoid virtual functions completely. But curiously recurring templates could still be useful - if I were to perform a series of operations on a single shape, I could use a virtual function to get an ID number for the underlying type, and cast it to BaseClass<thatType> (essentially my own RTTI), and then operate on it that way, avoiding the virtual functions... but then I guess if you're going to do that, you might just as well cast to 'thatType' itself and skip the base class.

---

quote:

---

Original post by Lepton
and im in no doubt that he used sources for this article

---

class VirtualShape {
public:
	virtual void VirtualDraw() = 0;
};

template <typename ShapeType>
class Shape : public VirtualShape {
public:
	void Draw() const {
		static_cast<const ShapeType *>(this)->Draw();
	};
};

class Rectangle : public Shape<Rectangle> {
public:
	void Draw() {
		printf("drawarect\n");
	}
	virtual void VirtualDraw() {Rectangle::Draw();};
};

class Circle : public Shape<Circle> {
public:
	void Draw() {
		printf("drawacircle\n");
	}
	virtual void VirtualDraw() {Circle::Draw();};
};


template<typename ShapeType>
void DrawAShapeOverAndOver(ShapeType* myShape)
{
  for(int i=0; i<5; i++)
  {
    myShape->Draw();
  }
}

void DrawAChangingShapeOverAndOver(VirtualShape **myShape) {
 for(int i=0; i<5; i++)
  {
    myShape[i]->VirtualDraw();
  }
}

quote:

---

Original post by Seriema
SpecificType *mySpecificObjectPtr = new SpecificType();
mySpecificObjectPtr->CallAnyFunctionThatSpecificTypeHas();

that's basicly what I saw... You don't need virtual functions. You can inherit or not, either way, all functions that SpecificType has will be called without vtbl overhead.

---

quote:

---

Original post by Captian Goatse
This idea somehow perverts the initial idea of polymorphism and object structure.

First we may ask these questions:
Does a picture draw itself?
picture.draw();
No.

Does artist draw the picture?
artist.draw(picture);
Yes.

In this case we can still use the same method, however if you are going to be strict about polymorphism, this is the "more" right way.

---

quote:

---

Article
We will make it specifically for Rectangles, so we can just flat-out tell the dumb compiler what it is and forego the lookup code.

void DrawAShapeWhichIsARectangleOverAndOver(Shape* myShape)
{
  for(int i=0; i<10000; i++)
  {
    reinterpret_cast<Rectangle*>(myShape)->DrawOutline();
  }
}

Unfortunately, this doesn't help one bit. Telling the compiler that the object is a Rectangle isn't enough. For all the compiler knows, the object could be a subclass of Rectangle.

---

void DrawAShapeWhichIsARectangleOverAndOver(Shape* myShape)
{
  for(int i=0; i<10000; i++)
  {
    reinterpret_cast<Rectangle*>(myShape)->Rectangle::DrawOutline();
  }
}

quote:

---

Original post by Beer Hunter
Right. However, you can specifically call Rectangle::DrawOutline like this:

---

void DrawAShapeOverAndOver(Shape* myShape)
{
  void (*Draw)();

  Draw = myShape->DrawOutline;

  for(int i=0; i<10000; i++)
  {
    Draw();
  }
}