hmmm... tu pourrais mettre les fichiers " pret à compiler" sur un ftp et donner l´url, ça nous permettrait de les ouvrir dans un IDE et de tester, ça serait beaucoup plus pratique et lisible ?
sinon, sur le principe, un lieu de faire un constructeur " de conversion", pourquoi ne pas faire un véritable opérateur de conversion ? dans le style :

class Vector
{
public:
Vertex operator ( ) { return Vertex(.....); }
};

enfin, si tu restes avec les ctor, envisages éventuellement d´en passer en explicit, sans quoi certaines conversions couteuses passent parfois inaperçues.

sinon, pour avoir implémenter à plusieurs reprises de telles classes ( on en a toujours besoin et jamais l´api a utiliser ne dispose de ce qu´on veut ; ) . .. exception, directx selon moi), tu pourrais p-e gagner bcp de temps avec un template Tuple, suivi de qq typedefs : un vector ou un vertex n´étant au fond qu´une interprétation différente de données similaires. Et ça permet de faire facilement " point + vecteur donne point" par exemple, du coup ça devient asses intuitif.
apres, tout dépend de comment tu envisages ta lib maths ; bonne continuation !

HS_Dino : ah oui, bien vu, c´est vrai qu´on gagne la réciprocité avec les operator friend ; mais... est-ce qu´on peut avoir un opérateur non symétrique en friend ? genre faire :

type1 operator +(const Type2 &, const Type3 &);
type1 operator +(const Type3 &, const Type2 &);

faudra que je teste tiens, ça peut etre amusant.

Hein?! non, on gagne la reciprocite avec les operator friend que si on en defini deux.. De plus, si avec un int les friends peuvent etre utilent, c´est souvent genant de devoir tout remettre en friend pour les fils:
( mauvais exemple, mais exemple tout de meme)

/ * le hpp */

1. ifndef _TEST_HPP_
2. define _TEST_HPP_

class Entier;

class Vector
{
public:

friend class Entier;

Vector( const double x_, const double y_, const double z_ ) ;

private:

double x, y, z;

};

class Entier
{

public:
Entier( int e_ ) ;

virtual void addToVectorX( Vector & ) const;

private:
const int e;

};

class Float : public Entier
{
public:
Float( const float f_ ) ;

void addToVectorX( Vector & ) const;

private:
const float f;

};

1. endif / * _TEST_HPP_ */

/ * le cpp */

1. include " Test.hpp"

Vector::Vector( const double x_, const double y_, const double z_ ) : x( x_ ) , y( y_ ) , z( z_ ) {}

Entier::Entier( int e_ ) : e( e_ ) { }

void Entier::addToVectorX( Vector & ) const
{
vec.x += e;
}

Float::Float( const float f_ ) : Entier( static_cast<int>(f_) ) , f( f_ ) {}

void Float::addToVectorX( Vector & ) const
{
vec.x += f; / / erreur
}

int main( int argc, char ** argv )
{
Vector v1( 1.0, 2.0, 3.0 ) ;
Entier e1( 3 ) ;
Float f1( 2.6f ) ;

e1.addToVectorX( v1 ) ;
f1.addToVectorX( v1 ) ; / / error

return 0;
}