Type de #définir des variables

Si j'ai:

#define MAXLINE    5000

Ce type est MAXLINE entendre? Dois-je suppose que c'est un int? Puis-je le tester en quelque sorte?

En général, comment peut-on déterminer le type de #defineed variable?

InformationsquelleAutor JAM | 2011-12-21
  1. 43

    Il n'a pas de type. C'est un simple texte de substitution. Le texte 5000 seront déposés en lieu où MAXLINE apparaît comme un jeton.

    Par exemple:

    int a = MAXLINE;

    va mettre la valeur de 5000 dans a.

    Tout

    char *MAXLINE2 = "MAXLINE";

    n'entraînera pas de 

    char *50002 = "5000";

    Donc, si vous voulez la vérification de type, macro sont pas la voie à suivre. Vous souhaitez déclarer des constantes statiques au lieu de cela, de cette façon, le type de vérification est effectuée par le compilateur.

    Pour plus d'informations sur les différences entre static, const, et #define, il existe de nombreuses sources, y compris cette question: Statique, à définir et à const en C

    InformationsquelleAutor tpg2114
  2. 8

    (Très!) Globalement, votre compilateur C va effectuer 3 tâches lors de l'exécution:

    1. Exécuter un prétraitement passer au-dessus de vos fichiers source,

    2. Exécuter un compilateur sur la séquence des fichiers source

    3. Exécuter un éditeur de liens sur l'objet résultant des fichiers.

    Les lignes commençant par une #, comme la ligne

    
#define MAXLINE    5000

    est géré par le préprocesseur phase. (grosso modo) Le préprocesseur va analyser un fichier et d'effectuer des substitutions de texte pour toutes les macros qu'il détecte. Il n'y a pas de notion de types dans le préprocesseur.

    Supposons que vous ayez les lignes suivantes dans votre fichier source:

    
#define MAXLINE    5000
int someVariable = MAXLINE;     //line 2
char someString[] = "MAXLINE";  //line 3

    Le préprocesseur permet de détecter la macro MAXLINE sur la ligne 2, et d'effectuer un remplacement de texte. Notez que sur la ligne 3 "MAXLINE" n'est pas traitée comme une macro comme c'est une chaîne littérale.

    Après le préprocesseur phase terminée, la phase de compilation ne verra que les suivantes:

    
int someVariable = 5000;        //line 2
char someString[] = "MAXLINE";  //line 3

    (les commentaires ont été laissés dans la clarté, mais sont normalement éliminés par le préprocesseur)
    Vous pouvez probablement utiliser une option du compilateur pour être en mesure d'inspecter la sortie du préprocesseur. Dans gcc le -E option de le faire.

    Noter que, bien que le préprocesseur n'a pas de notion de type, il n'y a aucune raison que vous ne pouvez pas inclure un type dans votre macro pour l'exhaustivité. par exemple,

    
#define MAXLINE    ((int)5000)
    InformationsquelleAutor Andrew Edgecombe
  3. 5

    le compilateur ne voit jamais la ligne de code, un préprocesseur s'exécute avant la compilation et de remplacer ces macros avec leurs valeurs littérales, voir le lien ci-dessous pour plus d'informations

    http://www.cplusplus.com/doc/tutorial/preprocessor/

    InformationsquelleAutor Muath Ali
  4. 3

    Il n'a pas de type. C'est juste un jeton qui le préprocesseur va mettre dans le code source avant de passer le code pour le compilateur. Vous pouvez le faire (ridicule) chose à déclarer une variable appelée x5000:

    #define APPEND(x,y) x ## y

int main() {
        int APPEND(x,5000);
        x5000 = 3;
}

    Le préprocesseur tourne que dans ce avant de passer le compilateur proprement dit:

    int main() {
        int x5000;
        x5000 = 3;
}

    Donc, juste parce que vous voyez 5000 dans une macro, il ne signifie pas qu'il doit être numérique en aucune façon.

    InformationsquelleAutor Aaron McDaid
  5. 2

    MAXLINE n'est pas une variable à tous. En fait, il n'est pas de la syntaxe C. Partie de la compilation processus exécute un préprocesseur avant le compilateur, et une de ces actions, le préprocesseur suffit de remplacer les occurrences de MAXLINE jetons dans le fichier source avec tout ce qui vient après #define MAXLINE (5000 dans la question du code).

    De côté: une autre façon dont vous utilisez le préprocesseur dans votre code avec le #include directive, qui le préprocesseur remplace simplement avec la séquence contenu du fichier inclus.

    Exemple

    Regardons un exemple du processus de compilation dans l'action. Voici un fichier, foo.c, qui sera utilisé dans les exemples:

    #define VALUE 4

int main()
{
  const int x = VALUE;
  return 0;
}

    - Je utiliser gcc et cpp (le préprocesseur C) pour les exemples, mais vous pouvez probablement le faire avec quel compilateur de suite, vous avez, avec des drapeaux différents, bien sûr.

    Compilation

    Tout d'abord, nous allons compiler foo.c avec gcc -o foo.c. Ce qui s'est passé? Il a travaillé; vous devriez maintenant avoir un fichier exécutable foo.

    Prétraitement seulement

    Vous pouvez dire gcc à seulement prétraiter et ne pas faire de la compilation. Si vous ne gcc -E foo.c, vous obtiendrez la séquence de fichier standard de sortie. Voici ce qu'il produit:

    # 1 "foo.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "foo.c"


int main()
{
  const int x = 4;
  return 0;
}

    Notez que la première ligne de main a remplacé VALUE avec 4.

    Vous demandez peut-être ce que les quatre premières lignes sont. Ceux-ci sont appelés linemarkers, et vous pouvez en lire plus à ce sujet dans Préprocesseur De Sortie.

    Compilation sans prétraitement

    Autant que je sache, vous ne pouvez pas carrément sauter de prétraitement dans gcc, mais un couple d'approches existent pour dire qu'un fichier a déjà été prétraitées. Même si vous faites cela, cependant, il va supprimer les macros présentes dans le fichier parce qu'ils ne sont pas pour le compilateur de la consommation. Vous pouvez voir ce que le compilateur travaille avec dans cette situation avec gcc -E -fpreprocessed foo.c:

    .
.
.
.
int main()
{
  const int x = VALUE;
  return 0;
}

    Note: j'ai mis les points dans le haut; faire semblant de ceux qui sont des lignes vides (j'ai dû les mettre là pour obtenir ces lignes à afficher par).

    Ce fichier ne sera pas clairement de la compilation (essayez gcc -fpreprocessed foo.c pour savoir) parce que VALUE est présent dans la source, mais n'est défini nulle part.

    InformationsquelleAutor David Alber
  6. 1

    Nous appelons cela de la macro ou de préprocesseur, qui est utilisé pour la chaîne de remplacer le fichier source du contenu. À lire: https://en.wikipedia.org/wiki/C_macro

    • À préciser: #define sont gérées par le "préprocesseur", et "pré-traitement" signifie "qu'il traite le texte source AVANT de le compilateur voit". Ce tpg2114 dit est correct: un COMPILATEUR comprend "types". Le préprocesseur est impliqué AVANT que - c'est simple remplacement de texte. Rien de plus.
    InformationsquelleAutor shinkou
  7. 1

    Oui, vous pouvez supposer qu'il est un int.

    Bien, en fait, toutes les autres réponses sont correctes. C'est pas du C, c'est juste
    une directive qui indique le préprocesseur de faire un texte
    des substitutions, et comme telle, elle n'a pas de type. Toutefois, si vous ne le faites pas tout
    funky choses avec elle (comme le ## préprocesseur truc), vous
    utilisez généralement MAXLINE comme une sorte de constante, et le préprocesseur
    va le remplacer par 5000 qui est en effet une constante explicite. Et
    les constantes ne sont de type: 5000 est un int. Une constante écrit comme un
    entier décimal, sans suffixe (comme en U ou en L), sera interprété par
    le compilateur comme une int, long int ou unsigned long int: la première
    de ces types qui s'adapte.

    Mais cela n'a évidemment rien à voir avec la preprecessor. Vous pourriez
    reformulez votre question “quel est le type de 5000?”, sans
    #define.

    InformationsquelleAutor Edgar Bonet