Limegarden.net Personal site of Wouter Lindenhof

#include <vector>
/* ...
 * Somewhere in the code
 * ...
 */
std::vector<int> numbers;
numbers.push_back(1);
numbers.push_back(2);
numbers.push_back(3);

/* Written for readability
 * And it only removes the first one it finds.
 */
template <typename T>
void RemoveFromVector(const T val, std::vector<T> vec)
{
    for(std::vector<T>::iterator begin = vec.begin(); begin != vec.end(); ++begin)
    {
        if(*begin == val)
        {
            vec.erase(begin);
            return;
        }
    }
}
/* ... And here we call it */
RemoveFromVector<int>(2, numbers);

/**
 * Previously the code was:
 * std::remove(numbers.begin(), numbers.end(), 2);
 * But that only removes the number, but keeps the same size. std::remove instead
 * returns an iterator which holds the end. (numbers.size() would give the same
 * result before and after the above code.
 * Thanks to  Arseny Kapoulkine this has been corrected and the good version is
 * now here available.
 */
numbers.erase( std::find(numbers.begin(), numbers.end(), 2) );

#include <vector>
#define SAFE_DELETE(p) if(p) delete(p); (p)=0;
class StorageObject1;
class StorageObject2;
class StorageContainer
{
    std::vector<StorageObject1*> m_Objects1;
    std::vector<StorageObject2*> m_Objects2;
public:
    ~StorageContainer()
    {
        for(size_t i = 0; i < m_Objects1.size(); ++i)
        {
            SAFE_DELETE(m_Objects1[i]);
        }
        for(size_t i = 0; i < m_Objects2.size(); ++i)
        {
            SAFE_DELETE(m_Objects2[i]);
        }
    }
};

#include <algorithm>
#include <vector>
#define SAFE_DELETE(p) if(p) delete(p); (p)=0;
template <typename T> void SAFE_DELETE_FUNC(T* object) { SAFE_DELETE(object); }
class StorageObject1;
class StorageObject2;
class StorageContainer
{
    std::vector<StorageObject1*> m_Objects1;
    std::vector<StorageObject2*> m_Objects2;
public:
    ~StorageContainer()
    {
        std::for_each(m_Objects1.begin(), m_Objects1.end(), SAFE_DELETE_FUNC<StorageObject1>);
        std::for_each(m_Objects2.begin(), m_Objects2.end(), SAFE_DELETE_FUNC<StorageObject2>);
    }
}

Undesired template specification

Updated 10 January 2010: The download was not working, this is now fixed

Yesterday I decided to improve my math library and to make it more flexible. One of the things that I wanted to do was convert it to a template, so that I could easily make vectors of different types. However when it was finished and I started testing it I came across a lot of issues which my old math library didn't have. The reason that my old library didn't have them was because all of the structures used floats and when used with any other variable type would be automatically be casted, promoted or demoted to match the type float. However templates are more strict on that area since templates need to specialize. I know this is confusing so let me explain by example.
I will show three examples of the above problem and I will explain how to solve any of them. I hope that throughout the progress you will also understand why the problems happen.
But first let me define the class that I use. This piece of code won't change until I cover the solution of the third problem.
The Vector2 class:

[cc_cpp]
template class tVector2
{
public:
T X, Y;
tVector2(T x, T y) : X(x), Y(y) {}
// Assigrnent operator
tVector2 operator = (tVector2 v) { X = v.X, Y=v.Y; return *this; }
};
// Multiplication operator
template tVector2 operator * (tVector2 v, T r) { return tVector2(v.X*r, v.Y*r); }
[/cc_cpp]

FIRST PROBLEM: ONLY A SINGLE TEMPLATE ARGUMENT

The first problem shows itself rather fast.

[cc_cpp]
int testMain1() // Think of this as a normal main
{
tVector2 Vec2(1,1);
Vec2 = Vec2 * 2.0f; // Does compile
Vec2 = Vec2 * 2.0; // Does not compile
return 0;
}
[/cc_cpp]

Visual Studio comes with two errors:

[ccWN_text]error C2782: 'tVector2 operator *(tVector2,T)' : template parameter 'T' is ambiguous
error C2676: binary '*' : 'tVector2' does not define this operator or a conversion to a type acceptable to the predefined operator[/ccWN_text]

If we think about the reason for this problem is rather easy. If we would think as the compiler we would have the following two forms of multiplication:

[cc_cpp]
tVector2 operator * (tVector2 v, float r);
tVector2 operator * (tVector2 v, double r);
[/cc_cpp]

The first multiplication in the example does compile as it makes use of the first form, the second multiplication in the example however raises two errors. As you can see neither form can be applied on our multiplication, which has the form [cci_cpp]tVector2[/cci_cpp] multiplied by a double. Since the compiler can't figure out whether template argument T is a float or a double, he throws the error that is ambiguous.
The second error comes forth because the compiler still tries to solve. However it cannot convert [cci_cpp]tVector2[/cci_cpp] to a [cci_cpp]tVector2[/cci_cpp] and he can't demote the second argument "2.0" to a float because their second form exists and denies him from demoting just like the following examples forbids only using the first form.

[cc_cpp]
void TestFunction(float v);
void TestFunction(double v);

int main()
{
TestFunction(2.0f); // Use first form
TestFunction(2.0 ); // Use second form
return 0;
}
[/cc_cpp]

FIRST SOLUTION: USE MULTIPLE TEMPLATE ARGUMENTS

The title of the first solution might feel contradicting as [cci_cpp]tVector2[/cci_cpp] does not change, but it is rather easy. We simply add another operator which look as followed.

[cc_cpp]
template
tVector2 operator * (tVector2 v, R r) {
return tVector2(v.X*r, v.Y*r);
}[/cc_cpp]

The biggest change is that because of using two template arguments, which are used for the first and second argument, is that compiler no longer have to match the types. So the compiler can generate the following:

[cc_cpp]
tVector2 operator * (tVector2 v, int r);
tVector2 operator * (tVector2 v, float r);
tVector2 operator * (tVector2 v, double r);
[/cc_cpp]

And the everything works. You can even remove the old multiplication method if you want.

SECOND PROBLEM: MULTIPLYING DIFFERENT TYPES

This problem is exactly the same as the first one, but I cover it none the less as it took me a few seconds more to realize this than I wanted.

[cc_cpp]
int testMain2() // Think of it as a seperate program
{
// Second problem: Multiplying different types
tVector2 Vec2(1,1);
tVector2 Vec2d(1,1);
Vec2d = Vec2d * Vec2; // tVector2=tVector2*tVector2
return 0;
}[/cc_cpp]

When we compile this visual studio comes two times with two different errors (total is four):

[ccWN_text]error C2784: 'tVector2 operator *(tVector2,R)' : could not deduce template argument for 'tVector2' from 'double'
error C2677: binary '*' : no global operator found which takes type 'tVector2' (or there is no acceptable conversion)[/ccWN_text]

The errors all take place in the solution of the previous problem as it tries to solve that function in to the following form:

[cc_cpp]tVector2 operator * (tVector2 v, tVector2 r){
return tVector2(v.X*r, v.Y*r);
}[/cc_cpp]

I have added on purpose also the body of the form because that is what you should concentrate on. As you can see it tries to multiply [cci_cpp]v.X[/cci_cpp] with [cci_cpp]r[/cci_cpp]. While [cci_cpp]v.X[/cci_cpp]is a float, which is correct. [cci_cpp]r[/cci_cpp] is of the type [cci_cpp]tVector2[/cci_cpp] and although there are times where this kind of multiplication is correct, the result would be a tVector2 which is wrong. In fact the above code could even be made working with a few simple steps. It would not give the result we are looking for, but it would work. The wrong steps would be, adding a new constructor which has as input two vectors and allowing numbers be multiplied by vectors (like in the first solution, but then the two function arguments switched around). However I will provide you with the correct solution.

SECOND SOLUTION: USE MULTIPLE TEMPLATE ARGUMENTS WITH TYPES

Similar to the first problem we add the following function:

[cc_cpp]template
tVector2 operator * (tVector2 v, tVector2 r) {
return tVector2(v.X*r.X, v.Y*r.Y);
}[/cc_cpp]

There is however one down side to this solution and that is that type returned is the same as the first template argument, even if the second template argument would be bigger. For example the first template argument is a float and the second is of the type double. In that case we would lose precision.

THIRD PROBLEM: CONVERTING FROM ONE TYPE TO ANOTHER TYPE

The test case is similar to that of the second problem, but with a little change.

[cc_cpp]int testMain3() // Think of it as a seperate program
{
// Third problem: Storing different types
tVector2 Vec2(1,1);
tVector2 Vec2d(1,1);
Vec2d = Vec2 * Vec2d; // tVector2 = tVector2 * tVector2
return 0;
}[/cc_cpp]

As you can see the result of the multiplication is now [cci_cpp]tVector2[/cci_cpp] while it previously was a [cci_cpp]tVector2[/cci_cpp]. This multiplication works, but the problem is the assignment operation. We try to store a [cci_cpp]tVector2[/cci_cpp] in a [cci_cpp]tVector2[/cci_cpp] and that is not allowed. If you look back at the original class you will see that the assignment operator requires that the function argument is of the same type as the class to which it belongs. And if there is one thing I have learned from the previous problem then it is that is not allowed.
However unlike the solutions of the first two problems, this operator needs to be a member function. So we should store a tVector of a unknown type in a tVector of a specialized type (which is actually also unknown, but the compiler specializes this so it is known to him, but not to us).

THIRD SOLUTION: TEMPLATE FUNCTION INSIDE A TEMPLATE CLASS

To be honest, I didn't think this was at all possible but since I had solved the previous two problems I was intended to find a solution for this one as well. In retrospect the solution was just as simple as the previous one, but then again everything seems easy in retrospect.
The new class looks as followed:

[cc_cpp]template class tVector2
{
public:
T X, Y;
tVector2(T x, T y) : X(x), Y(y) {}
// Assigment operator (didn't solve the third problem)
tVector2 operator = (tVector2 v) { X = v.X, Y=v.Y; return *this; }

// Assigment operator which allows other types (solved third problem)
template tVector2 operator = (tVector2 v){
X = v.X, Y=v.Y; return *this; }
};[/cc_cpp]

As you can see a new function has been added, which is a template function. Quite a simple and elegant solution once you accept the fact that you are allowed to create template functions inside a class as well.

FINAL WORDS

Although the title of the article is "Undesired template specification" it was only how I felt when I encountered all these problems. Afterwards I think it was not undesired at all, because this is how the language should work. If it wouldn't work like this we would barely have control what some of the functions would and then it would really become undesired.
I hope that the all of the above was easy enough to follow (assuming you are familiar with templates) and helped you understand in what went wrong and how to solve it.
As usual I have added the full source code at the bottom of the article. All the functions are in it, however in a production environment I would recommend you remove the old versions of some of the functions since the new functions also cover the functionality of the old ones.

Source code: templatetest_0.zip (2 kb)

class HelloWorldReceiver : public IReceiver
{
public:
	HelloWorldReceiver()
	{
		m_Translators.push_back( CTranslator<HelloWorldReceiver, WorldNote>() );
		m_Translators.push_back( CTranslator<HelloWorldReceiver, HelloNote>() );
	}
	void Receive(WorldNote* aWorld) {	}
	void Receive(HelloNote* aHello) {	}
};

class HelloWorldVisitor : public tAcyclicVisitor<HelloWorldVisitor>
public:
	HelloWorldVisitor() {
		RegisterAVObject<Hello>();
		RegisterAVObject<World>();
	}
	void Receive(Hello* obj) {	}
	void Receive(World* obj) {	}
};

// The MIT License
//
// Copyright (c) 2009 Wouter Lindenhof (http://limegarden.net)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#ifndef __ACYCLIC_VISITOR_H__
#define __ACYCLIC_VISITOR_H__
#include <list>

/**
 * @brief if set to 1 it will allows the user to combine derived acyclic
 * visitors, but this is likely to have a cost because of virtual inheritance.
 */
#define AV_ALLOW_VIRTUAL_INHERITANCE 1

/**
 * @brief this is the base object
 */
class AVBaseObject
{
public:
	virtual ~AVBaseObject() {}
};

class AcyclicVisitor;

class IAVTranslator
{
public:
	virtual const bool Accept(AVBaseObject* object, AcyclicVisitor* visitor) const = 0;
};

class AcyclicVisitor
{
	typedef std::list<IAVTranslator*> TransList;
protected:
	TransList m_AV_Translators;
public:
	virtual ~AcyclicVisitor() {
		for( TransList::iterator it = m_AV_Translators.begin(); it != m_AV_Translators.end(); ++it )
			delete (*it);

		m_AV_Translators.clear();
	}
	void Visit(AVBaseObject* baseObject)
	{
		for( TransList::iterator it = m_AV_Translators.begin(); it != m_AV_Translators.end(); ++it )
			(*it)->Accept(baseObject, this);
	}
};

template <typename V, typename O>
class tAVTranslator : public IAVTranslator
{
public:
	const bool Accept(AVBaseObject* object, AcyclicVisitor* visitor) const
	{
		V* original_visitor = dynamic_cast<V*>(visitor);
		O* original_object  = dynamic_cast<O*>(object);
		if(original_object == 0 || original_visitor == 0) return false;
		original_visitor->Receive(original_object);
		return true;
	}
};

template <typename V>
#if AV_ALLOW_VIRTUAL_INHERITANCE == 1
class tAcyclicVisitor : public virtual AcyclicVisitor
#else
class tAcyclicVisitor : public AcyclicVisitor
#endif
{
protected:
	template <typename O> void RegisterAVObject()
	{
		m_AV_Translators.push_back(new tAVTranslator<V, O>());
	}
};

#endif 

#include <windows.h>
#include <d3d9.h>
#pragma comment(lib, "d3d9.lib")
#include <d3dx9.h>
#pragma comment(lib, "d3dx9.lib")

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
	static TCHAR szAppName[] = TEXT ("DirectXStreamExample");
	HWND         hwnd;
	MSG          msg;
	WNDCLASSEX   wndclassex = {0};
	wndclassex.cbSize        = sizeof(WNDCLASSEX);
	wndclassex.style         = CS_HREDRAW | CS_VREDRAW;
	wndclassex.lpfnWndProc   = WndProc;
	wndclassex.cbClsExtra    = 0;
	wndclassex.cbWndExtra    = 0;
	wndclassex.hInstance     = hInstance;
	wndclassex.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
	wndclassex.hCursor       = LoadCursor (NULL, IDC_ARROW);
	wndclassex.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
	wndclassex.lpszMenuName  = NULL;
	wndclassex.lpszClassName = szAppName;
	wndclassex.hIconSm       = wndclassex.hIcon;

	if (!RegisterClassEx (&amp;wndclassex))
	{
		MessageBox (NULL, TEXT ("RegisterClassEx failed!"), szAppName, MB_ICONERROR);
		return 0;
	}
	hwnd = CreateWindowEx (WS_EX_OVERLAPPEDWINDOW,
		szAppName,
		TEXT ("DirectXStreamExample"),
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		640,
		480,
		NULL,
		NULL,
		hInstance,
		NULL); 

	ShowWindow (hwnd, iCmdShow);
	UpdateWindow (hwnd);

	// Now setup DirectX
	IDirect3D9* d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
	D3DPRESENT_PARAMETERS presentParameters;
	memset(&amp;presentParameters, 0, sizeof(D3DPRESENT_PARAMETERS));
	presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
	presentParameters.BackBufferFormat = D3DFMT_UNKNOWN;
	presentParameters.Windowed = true;
	IDirect3DDevice9* device = 0;
	d3d9->CreateDevice(0, D3DDEVTYPE_HAL, hwnd, D3DCREATE_MIXED_VERTEXPROCESSING, &amp;presentParameters, &amp;device);

	// Create our custom vertex format
	struct POSCOLORVERTEX
	{
		float X, Y, Z, W;
		DWORD color;
	};
	POSCOLORVERTEX vertices[] = {
		{150.0f,  50.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(255,0,0)},
		{250.0f, 250.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(0,255,0)},
		{ 50.0f, 250.0f, 0.5f, 1.0f, D3DCOLOR_XRGB(0,0,255)},
	};

	// Create a vertex decleration
	// Think of a vertex decleration as an object that describes a single custom
	// vertex.

	// 	typedef struct _D3DVERTEXELEMENT9
	// 	{
	// 		WORD    Stream;     // Stream index
	// 		WORD    Offset;     // Offset in the stream in bytes
	// 		BYTE    Type;       // Data type
	// 		BYTE    Method;     // Processing method
	// 		BYTE    Usage;      // Semantics
	// 		BYTE    UsageIndex; // Semantic index
	// 	} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;

	// Example 1: Tutorial 1 of the DirectX SDK
	// using weighted position (aka screen coordinates) and colors but without
	// using the Fixed Pipeline
	D3DVERTEXELEMENT9 PosColorVertexElements[] = {
		{0, 0,  D3DDECLTYPE_FLOAT4,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,	0},
		{0, 16, D3DDECLTYPE_D3DCOLOR,	D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,		0},
		D3DDECL_END()
	};

#if 0
	// Example 2: If you want to add UV it would become something like this:
	D3DVERTEXELEMENT9 PosColorUVVertexElements[] = {
		{0, 0,  D3DDECLTYPE_FLOAT4,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,	0},
		{0, 16, D3DDECLTYPE_D3DCOLOR,	D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,		0},
		{0, 20, D3DDECLTYPE_FLOAT2,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,	0},
		D3DDECL_END()
	};
	// Example 3: And if you want UVs first
	D3DVERTEXELEMENT9 PosColorNormalVertexElements[] = {
		{0, 0,		D3DDECLTYPE_FLOAT2,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,	0},
		{0, 8,		D3DDECLTYPE_FLOAT4,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,	0},
		{0, 8+16,	D3DDECLTYPE_D3DCOLOR,	D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,		0},
		D3DDECL_END()
	};
	// Example 4: And if you want to send two UV's
	D3DVERTEXELEMENT9 PosColorNormalVertexElements[] = {
		{0, 0,  D3DDECLTYPE_FLOAT4,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,	0},
		{0, 16, D3DDECLTYPE_D3DCOLOR,	D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,		0},
		{0, 20, D3DDECLTYPE_FLOAT2,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,	0}, // Maps to TEXCOORD0 in shader
		{1, 28, D3DDECLTYPE_FLOAT2,		D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,	0},	// Maps to TEXCOORD1 in shader
		D3DDECL_END()
	};
#endif

	IDirect3DVertexDeclaration9* vertexDecleration = 0;
	device->CreateVertexDeclaration(PosColorVertexElements, &amp;vertexDecleration);
	device->SetVertexDeclaration(vertexDecleration);

	// Create vertex buffer
	IDirect3DVertexBuffer9*  vertexBuffer;
	device->CreateVertexBuffer(
		3*sizeof(POSCOLORVERTEX),
		0,
		0,								// DON'T pass the FVF code if you are using vertex decleration
		D3DPOOL_DEFAULT,
		&amp;vertexBuffer,
		0);

	// Fill the vertex buffer
	void* pVertices = 0;
	vertexBuffer->Lock(0, sizeof(vertices), (void**)&amp;pVertices, 0);
	memcpy(pVertices, vertices, sizeof(vertices));
	vertexBuffer->Unlock();

	bool keepRunning = true;

	while(keepRunning)
	{
		// Render
		device->Clear(0, 0, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
		device->BeginScene();
		// Rendering of scene objects happens here
		// 1. Set the vertex decleration
		// 2. Set the stream source
		device->SetVertexDeclaration(vertexDecleration);
		device->SetStreamSource(0, vertexBuffer, 0, sizeof(POSCOLORVERTEX));
		device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
		// End the scene
		device->EndScene();
		device->Present(0,0,0,0);

		if (PeekMessage(&amp;msg, NULL, 0, 0, PM_REMOVE))
		{
			if(msg.message == WM_QUIT) keepRunning = false;
			else
			{
				TranslateMessage (&amp;msg);
				DispatchMessage (&amp;msg);
			}
		}
	}

	vertexBuffer->Release();
	vertexDecleration->Release();
	device->Release();
	d3d9->Release();

	return msg.wParam;
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_DESTROY:
		{
			PostQuitMessage (0);
			return (0);
		}break;
	}
	return DefWindowProc (hwnd, message, wParam, lParam);
}