Existe-t-il un moyen de définir un terme défini?

Question

#define BLAH word 

cout << BLAH; 

Y at-il un moyen de le faire?

Answer 1

1. 'cout' n'est pas quelque chose que vous faites. C'est une variable globale, qui est une instance du type std::ostream. Vous pourriez dire par exemple "sortie à cout".

2. #define fait une substitution textuelle. Il est fondamentalement le même que si vous avez utilisé search-and-replace dans votre éditeur de texte pour remplacer BLAH par word. Ainsi, la ligne cout << BLAH; se transforme en cout << word;. Si cela ne fonctionne pas, c'est parce que cout << word; n'est pas une déclaration valide dans cette portée. Le préprocesseur ne se soucie pas du texte environnant. Il a essentiellement zéro compréhension du code (il sait tokenize le code, à savoir Segmenter les opérateurs et autres signes de ponctuation si vous ne mettez pas d'espace, mais qui est à ce sujet.)

Answer 2

Si vous voulez d'imprimer le mot "word", vous pouvez faire:

#define STRINGIFY(x) #x 

cout << STRINGIFY(word); 

Answer 3

Essayez

#define STRINGIFY(x) #x 
#define STRINGIFYMACRO(y) STRINGIFY(y) 

#define BLAH word 
cout << STRINGIFYMACRO(BLAH); 

le niveau d'indirection supplémentaire entraîne la valeur de la macro à la place du de chaîne de caractères nom de la macro.

Tested on ideone.

Answer 4

OK, nous allons essayer à nouveau ce, en fonction de votre commentaire:

Je teste un programme pour les différentes représentations du nombre, à savoir float et double. Je veux imprimer: "Testing for float" lorsque le terme défini est float.

On dirait que c'est ce que vous voulez dire vraiment:

je code comme suit:

cout << "As a float:" << float(value) << endl; 
cout << "As a double:" << double(value) << endl; 

et je veux faire une macro pour chacun ces lignes de sorte que le texte corresponde à la typographie.

Dans ce cas, vous voulez quelque chose comme ceci:

#define DEBUG(t, x) cout << "As a " #t ":" << t(x) << endl 

DEBUG(float, value); 
DEBUG(double, value); 

Answer 5

Je suppose que vous voulez quelque chose comme ceci:

#include <typeinfo> 

template <typename T> 
void print_type() 
{ 
    std::cout << typeid(T).name() << std::endl; 
} 

int main() 
{ 
    print_type<float>(); 
    print_type<int>(); 
} 

Notez que la valeur de typeid(T).name() est définie la mise en œuvre, et peut-être rien du tout. Il n'y a aucun moyen d'imprimer un type d'une manière garantie sans écrire une fonction vous-même, pour chaque type.

Vous pouvez faire une surcharge qui en déduit le type de l'expression aussi: (. Notez que ce évalue l'expression, ce qui est inutile, mais je doute que ce soit une préoccupation)

#include <typeinfo> 

template <typename T> 
void print_type(const T&) 
{ 
    std::cout << typeid(T).name() << std::endl; 
} 

int main() 
{ 
    print_type(5.0f); 
    print_type(5.0); 
} 

Answer 6

Je suis en train de tester un programme pour différentes représentations de nombres, c'est-à-dire float et double. Je veux imprimer: "Testing for float" lorsque le terme défini est float.

Pas besoin d'abuser de macros comme typedef primitive:

template<class T> 
void do_test(char const *name) { 
    std::cout << "Testing " << name << "...\n"; 
    T var = foo(); 
    bar(var); 
} 

int main() { 
    do_test<float>("single precision"); 
    do_test<double>("double precision"); 
    return 0; 
} 

Avis cela vous permet de donner des noms différents (je l'espère plus significatives) pour chaque test, plutôt que stringizing les paramètres à l'épreuve, mais "float" et "double" pourraient être les noms si vous le souhaitez.

Si vous avez vraiment voulu stringize les paramètres - ou si vous êtes simplement curieux au sujet des macros:

#define DO_TEST(T) do_test<T>(#T) 
int main() { 
    DO_TEST(float); 
    DO_TEST(double); 
    return 0; 
}