Dado que el compilador debe decidir cómo realizar silenciosamente una conversión de tipos, puede meterse en problemas si el programador no diseña las conversiones correctamente. Una situación simple y obvia se da con una clase X que puede convertirse a sí misma en un objeto de la clase Y mediante un operator Y(). Si la clase Y tiene un constructor que toma un único argumento de tipo X, esto representa la misma conversión de tipos. El compilador ahora tiene dos formas de ir de X a Y, así que generará un error de ambigüedad cuando se produzca esa conversión:

//: C12:TypeConversionAmbiguity.cpp
class Orange; // Class declaration

class Apple {
public:
  operator Orange() const; // Convert Apple to Orange
};

class Orange {
public:
  Orange(Apple); // Convert Apple to Orange
};

void f(Orange) {}

int main() {
  Apple a;
//! f(a); // Error: ambiguous conversion
} ///:~

La solución obvia a este problema es no hacerlo. Simplemente proporcione una ruta única para la conversión automática de un tipo a otro.

Un problema más difícil de detectar sucede cuando proporciona conversiones automáticas a más de un tipo. Esto se llama a veces abanico de salida (fan-out):

//: C12:TypeConversionFanout.cpp
class Orange {};
class Pear {};

class Apple {
public:
  operator Orange() const;
  operator Pear() const;
};

// Overloaded eat():
void eat(Orange);
void eat(Pear);

int main() {
  Apple c;
//! eat(c);
  // Error: Apple -> Orange or Apple -> Pear ???
} ///:~

La clase Apple tiene conversiones automáticas a Orange y a Pear. Lo insidioso de esto es que no hay ningún problema hasta que alguien llega inocentemente y crea dos versiones sobrecargadas de eat(). (Con una única versión el código en main() funciona correctamente).

De nuevo la solución -- y el lema general de la conversión automática de tipos -- es proporcionar solo una conversión automática de un tipo a otro. Puede tener conversiones a otros tipos, sólo que no deberían ser automáticas. Puede crear llamadas a funciones explícitas con nombres como makeA() y makeB().

//: C12:CopyingVsInitialization2.cpp
class Fi {};

class Fee {
public:
  Fee(int) {}
  Fee(const Fi&) {}
};

class Fo {
  int i;
public:
  Fo(int x = 0) : i(x) {}
  operator Fee() const { return Fee(i); }
};

int main() {
  Fo fo;
  Fee fee = fo;
} ///:~

Fee fee = fo;