opérateur de conversion défini par l'utilisateur comme argument pour printf

Question

J'ai une classe qui a défini un opérateur défini par l'utilisateur pour un TCHAR *, comme si

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

Je veux être capable de faire quelque chose comme

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

ou même

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

Mais en essayant, printf toujours des impressions (null) au lieu de la valeur. J'ai aussi essayé un opérateur normal char *, ainsi variations avec const etc. Il ne fonctionne correctement que si je l'appelle explicitement l'opérateur ou faire un casting, comme

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

Cependant, je ne veux pas jeter. Comment cela peut-il être atteint?

Notez que la possibilité est de créer une fonction qui a un paramètre de const TCHAR *, de sorte qu'il appelle forcé l'opérateur TCHAR *, mais ce que je ne veux pas aussi à mettre en œuvre.

Answer 1

Évitez les opérateurs de conversion. Ils font rarement ce que vous voulez, puis les appels explicites sont douloureuses. Renommer operator const TCHAR*() const à TCHAR *str() const.

Answer 2

La norme C ++ dit que les conversions implicites comme celle-ci ne sont pas appliqués aux paramètres de suspension - comment le compilateur savoir ce que la conversion à appliquer? Vous devrez effectuer la conversion vous-même explicitement, ou mieux encore cesser d'utiliser printf.

Answer 3

Opérateurs de conversion sont appelés lorsque le compilateur veut convertir une valeur à un autre type. Cela fonctionne pour les fonctions qui prennent des paramètres définis de types spécifiques. Il ne fonctionne pas pour les fonctions variadique comme printf() avec ... dans la déclaration de fonction. Ces fonctions prennent les arguments et travailler avec eux, de sorte que l'opérateur de conversion est jamais appelé.

Pour être précis, lorsque le compilateur voit printf("%s", foo), il passe foo, quoi que ce soit, à printf(), qui devra assumer, il convient pour un format %s tel qu'il est. Aucun opérateur de conversion sera appelé (bien que certaines promotions arithmétiques auront lieu).

Opérateurs de conversion en général des problèmes de cause. En ayant cet opérateur dans cette classe, vous avez compliqué la résolution de surcharge de fonction, car le compilateur peut interpréter un CMyClass comme si elle était un TCHAR *. Cela peut provoquer des résultats inattendus, que ce soit le code faisant la compilation lorsque vous ne voulais vraiment pas, ou en sélectionnant la mauvaise fonction surcharge. (Par exemple, étant donné CMyClass cmc;, l'expression cmc + 10 est soudainement juridique, puisque TCHAR * + int est un pointeur arithmétique parfaitement légitime.) La pratique habituelle consiste à étiqueter explicit telles conversions.

Answer 4

Le casting est la bonne chose à faire si vous voulez utiliser les API de style printf et compter sur un opérateur de conversion (et je ne veux pas discuter ici si vous devez ou non utiliser ces fonctions). Cependant, je voudrais utiliser statique moulé, par exemple _tprintf(_T("%s\n"), static_cast<const TCHAR*>(myClass));