definido por el usuario operador de conversión como argumento para printf

Question

Tengo una clase que define un operador definido por el usuario para un TCHAR *, al igual que

CMyClass::operator const TCHAR*() const
{
    // returns text as const TCHAR*
}

Quiero ser capaz de hacer algo como

CMyClass myClass;
_tprintf(_T("%s"), myClass);

o incluso

_tprintf(_T("%s"), CMyClass(value));

Sin embargo, cuando se trata, siempre printf imprime (null) en lugar del valor. También he probado un operador de char * normal, así variaciones con const etc. Sólo funciona correctamente si llamo explícitamente el operador o hago un molde, como

_tprintf(_T("%s\n"), (const TCHAR*)myClass);
_tprintf(_T("%s\n"), myClass.operator const TCHAR *());

Sin embargo, no quiero echar. ¿Cómo se puede lograr esto?

Tenga en cuenta, que una posibilidad es crear una función que tiene un parámetro const TCHAR *, de modo que las llamadas forzosas del operador TCHAR *, pero esto también no quiero poner en práctica.

Answer 1

Los operadores de conversión evitar. Rara vez se haga lo que quiera, y luego las llamadas explícitas son dolorosas. Cambiar el nombre de operator const TCHAR*() const a TCHAR *str() const.

Answer 2

dice El estándar de C ++ que las conversiones implícitas de este tipo no se aplican a los parámetros suspensivos - ¿cómo el compilador saber lo que la conversión a aplicar? Tendrá que realizar la conversión explícita a sí mismo, o mejor aún, dejar de usar printf.

Answer 3

Los operadores de conversión son llamados cuando el compilador quiere convertir un valor a otro tipo. Esto funciona para las funciones que toman los parámetros definidos de tipos específicos. No funciona para funciones como variadic printf() con ... en la declaración de la función. Estas funciones toman los argumentos y luego trabajar con ellos, por lo que el operador de conversión nunca es llamado.

Para ser más específicos, cuando el compilador ve printf("%s", foo), pasa foo, sea lo que sea, a printf(), que tendrá que asumir que es adecuado para un formato %s tal como es. Se llamará ningún operador de conversión (aunque ciertas promociones aritméticas se llevarán a cabo).

operadores de conversión en problemas generales de causa. Al tener ese operador en esa clase, que ha complicado resolución sobrecarga de la función, ya que el compilador puede interpretar un CMyClass como si se tratara de un TCHAR *. Esto puede causar resultados inesperados, ya sea provocando código para compilar cuando realmente no quiere, o la selección de la función sobrecargada mal. (Por ejemplo, dada CMyClass cmc;, la cmc + 10 expresión es de repente legal, puesto TCHAR * + int es perfectamente legítimo aritmética de punteros). La práctica habitual es etiquetar tales conversiones explicit.

Answer 4

Casting es lo que hay que hacer si desea utilizar las API de estilo printf y se basan en un operador de conversión (y no voy a discutir aquí si debe o no utilizar estas funciones). Sin embargo, me gustaría utilizar vaciado estático, por ejemplo, _tprintf(_T("%s\n"), static_cast<const TCHAR*>(myClass));