// Utils.h
...
namespace ge {
    float FloatRandom(...);
}

//Utils.cpp
float ge::FloatRandom(...)
{
...
}

//Vector2.h
...{ge::FloatRandom(...)}

Von VidualC++2010 bekomme ich jedoch die Fehlermaldung, dass FloatRandom kein Element von ge sei. Die Datei Utils.h ist in Vector2.h eingebunden.
Ich hoffe, mir kann jemand helfen.

//Utils.cpp
GE_API float ge::FloatRandom(const float fMin, const float fMax)
{
	return fMin + (fMax - fMin) * ((float)(rand() %10001) / 10000.0f);
}

//Vector2.h
inline Vector2 Vector2Random()
	{
		return Vector2NormalizeEx(Vector2(ge::FloatRandom(-1.0f, 1.0f), ge::FloatRandom(-1.0f, 1.0f)));
	}

ok, hier mal der gesamte code:

Bring doch mal ein minimales, compilierbares (bis auf den Fehler) Beispiel mit klarer Fehlermeldung und Zeile des Fehlers. Sonst ist das vollkommen nutzlos. Was soll zum Beispiel die (wie schon erwähnt ohnehin fehlerhafte) Utils.cpp überhaupt mit dem Problem zu tun haben?

P.S.: Das sieht übrigens schwer danach aus, als würdest du die Standardbibliothek nachprogrammieren. (Der Artikel ist nicht ganz aktuell, das was tr1 war ist nun Teil des neuen 2011er Standards)

// main.h
#include "Utils.h"

int main(void)
{
	float fRandom;
	fRandom = ge::FloatRandom(-1.0f, 1.0f);
	return 0;
}

Fehlermeldung:
main.cpp(7): error C3861: "FloatRandom": Bezeichner wurde nicht gefunden.

.h

namespace leet
{
class fanboy
{
public :
int a;

void crew(int a);
}
}

.cpp

using namespace leet;

void fanboy::crew ....

main.cpp

using namespace leet;
fanboy f;
f.crew();

wenn ich das so mache , dan gehts

namespace ge
{
	class GE_API Matrix;

	class GE_API Vector2
	{
	public:
		union
		{
			struct
			{
				float x;
				float y;
			};

			struct
			{
				float u;
				float v;
			};

			float c[2];
		};

		Vector2() {};
		Vector2(const Vector2& v) : x(v.x), y(v.y) {}
		Vector2(const float f) : x(f), y(f) {}
		Vector2(float _x, float _y) : x(_x), y(_y) {}
		Vector2(float* pfComponent) : x(pfComponent[0]), y(pfComponent[1]) {}

		operator float* () {return (float*)(c);}

		Vector2& operator  = (const Vector2& v) {x = v.x; y = v.y; return *this;}
		Vector2& operator += (const Vector2& v) {x += v.x; y += v.y; return *this;}
		Vector2& operator -= (const Vector2& v) {x -= v.x; y -= v.y; return *this;}
		Vector2& operator *= (const Vector2& v) {x *= v.x; y *= v.y; return *this;}
		Vector2& operator *= (const float f) { x *= f; y *= f; return *this;}
		Vector2& operator /= (const Vector2& v) { x /= v.x; y /= v.y; return *this;}
		Vector2& operator /= (const float f) {x /= f; y /= f; return *this;}
	};

// Direct3D.h
#ifndef _DIRECT3D_H
#define _DIRECT3D_H

#include "GraphicEngine.h"

namespace ge
{
	union GE_API D3DRS
	{
		DWORD adwRS[210];
		float afRS[210];
	};

	union GE_API D3DTSS
	{
		DWORD adwTSS[8][33];
		float afTSS[8][33];
	};

	union GE_API D3DSS
	{
		DWORD adwSS[8][14];
		float afSS[8][14];
	};

	class GE_API Direct3D
	{
	public:
		bool m_bInitialized;
		HWND m_hWindow;
		bool m_bOwnWindow;
		PDIRECT3D9 m_pD3D;
		PDIRECT3DDEVICE9 m_pD3DDevice;
		D3DCAPS9 m_Caps;
		D3DPRESENT_PARAMETERS m_PresentParameters;
		ge::Vector2 m_vScreenSize;
		geResult m_PresentResult;

		D3DRS m_RS;
		D3DTSS m_TSS;
		D3DSS m_SS;

		DWORD m_dwFVF;
		PDIRECT3DBASETEXTURE9 m_apTexture[8];
		bool m_abIsRS[210];
		bool m_abIsTSS[33];
		bool m_abIsSS[14];

		Direct3D() {};

	public:
		~Direct3D() {if(IsInitialized()) Exit();}

		geResult Init(DMXConfig* pConfig,
					  char* pcWindowTitle,
					  HWND hOwnWindow = NULL,
					  HICON hIcon = NULL);
		geResult Exit();
		geResult Capture();
		geResult Present();
		geResult SetRS(D3DRENDERSTATETYPE RS, DWORD dwValue);
		geResult SetRSF(D3DRENDERSTATETYPE RS, float fValue);
		DWORD GetRS(D3DRENDERSTATETYPE RS);
		float GetRSF(D3DRENDERSTATETYPE RS);
		geResult SetTSS(DWORD dwStage, D3DTEXTURESTAGESTATETYPE TSS, DWORD dwValue);
		geResult SetTSSF(DWORD dwStage, D3DTEXTURESTAGESTATETYPE TSS, float fValue);
		DWORD GetTSS(DWORD dwStage, D3DTEXTURESTAGESTATETYPE TSS);
		float GetTSSF(DWORD dwStage, D3DTEXTURESTAGESTATETYPE TSS);
		geResult SetSS(DWORD dwStage, D3DSAMPLERSTATETYPE SS, DWORD dwValue);
		geResult SetSSF(DWORD dwStage, D3DSAMPLERSTATETYPE SS, float fValue);
		DWORD GetSS(DWORD dwStage, D3DSAMPLERSTATETYPE SS);
		float GetSSF(DWORD dwStage, D3DSAMPLERSTATETYPE SS);
		geResult SetTexture(DWORD dwStage,
							PDIRECT3DBASETEXTURE9 pTesture);
		PDIRECT3DBASETEXTURE9 GetTexture(DWORD dwStage);
		geResult SetTransform(D3DTRANSFORMSTATETYPE Transform, const Matrix& mMatrix);
		Matrix GetTransform(D3DTRANSFORMSTATETYPE Transform);
		geResult SetFVF(DWORD dwFVF);

		PDIRECT3DDEVICE9 operator -> () {return m_pD3DDevice;}

		HWND GetWindow() {return m_hWindow;}
		bool GetOwnWindow() {return m_bOwnWindow;}
		PDIRECT3D9 GetD3D() {return m_pD3D;}
		PDIRECT3DDEVICE9 GetDevice() {return m_pD3DDevice;}
		DWORD getFVF() {return m_dwFVF;}
		const D3DCAPS9& GetCaps() {return m_Caps;}
		const D3DPRESENT_PARAMETERS& GetPresentParameters() {return m_PresentParameters;}
		const Vector2& GetScreenSize() {return m_vScreenSize;}
		float GetAspect() {return m_vScreenSize.x / m_vScreenSize.y;}
		geResult GetPresentResult() {return m_PresentResult;}

		static Direct3D& Instance();
		static bool IsInitialized() {return Instance().m_bInitialized;}

		friend LRESULT WINAPI WindowProc(HWND hWnd,
										 unsigned int uiMessage,
										 WPARAM WParam,
										 LPARAM LParam);
	};
}

#endif

Fehlermelung:

direct3d.h(39): error C2039: 'Vector2': Ist kein Element von 'ge'
direct3d.h(39): error C2146: Syntaxfehler: Fehlendes ';' vor Bezeichner 'm_vScreenSize'
direct3d.h(39): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.

Bevor jemand was sagt: Ja, ich weiß dass die Member in Direct3D public deklariert sind, werd das noch ändern.
Ich hoffe, jemand kann mir sagen, was ich falsch gemacht hab.