Extern et Statique des Pointeurs en C

Salut ce que pourrait être l'utilisation de la statique et extern pointeur ?? si elles existent

OriginalL'auteur Arpit | 2009-08-17

11

Pour répondre à votre question sur le moment où ils pourraient être utilisés, quelques exemples simples:

Statique pointeur peut être utilisé pour implémenter une fonction qui renvoie toujours le même tampon pour le programme, l'allocation de la première fois, il est appelé:
```
char * GetBuffer() {
   static char * buff = 0;
   if ( buff == 0 ) {
       buff = malloc( BUFSIZE );
   }
   return buff;
}
```
Externe (c'est à dire globale du pointeur peut être utilisé pour permettre à d'autres unités de compilation pour accéder aux paramètres principaux:
```
extern int ArgC = 0;
extern char ** ArgV = 0;

int main( int argc, char ** argv ) {
   ArgC = argc;
   ArgV = argv;
   ...
}
```
pourquoi buff est de type char? couldnt il serait int?
Il est de type char, parce que son un exemple. Il pourrait être de type int, double, yada yada.

OriginalL'auteur
8

Réponse courte: ils n'existent pas. C99 6.7.1 dit "tout Au plus, une catégorie de stockage spécificateur peut être donnée dans la déclaration des prescripteurs dans une déclaration". extern et static sont à la fois classe de stockage des prescripteurs.

C'est en répondant à une étonnante interprétation de la question. Je m'attends à la question: quelles sont les utilisations de la statique des pointeurs, et quelles sont les utilisations des extern pointeurs (comme je sais qu'il y en a un, je ne serais pas de qualification).

OriginalL'auteur CB Bailey
2

Voir Comment utiliser correctement le mot-clé extern en C

Et Interne des variables statiques en C, auriez-vous l'utiliser?

Essentiellement, "statique" (dans la norme C) lorsqu'elle est utilisée dans une fonction permet à une variable de ne pas être anéanti comme il le ferait normalement une fois que la fonction se termine (c'est à dire, il conserve son ancienne valeur chaque fois que la fonction est appelée). "Extern" élargit la portée d'une variable de sorte qu'il peut être utilisé dans d'autres fichiers (c'est à dire, il fait une variable globale).

OriginalL'auteur Michael

Supposons que j'ai un pointeur que je veux faire mondial à la disposition de plusieurs unités de traduction. Je veux définir dans un seul endroit (foo.c), mais de permettre à plusieurs déclarations dans d'autres unités de traduction. Le "extern" mot-clé indique au compilateur que ce n'est pas le définition déclaration de l'objet; la définition apparaître ailleurs. Il est tout simplement le nom de l'objet à la disposition de l'éditeur de liens. Lorsque le code est compilé et lié, toutes les différentes unités de traduction sera référencer le même objet de ce nom.

Supposons que j'ai aussi un pointeur que je veux faire mondial disposition des fonctions au sein d'un seul fichier source, mais pas visible par les autres unités de traduction. Je peux utiliser le mot clé "statique pour indiquer que le nom de l'objet ne pas être exportés à l'éditeur de liens.

Supposons que j'ai aussi un pointeur que je veux utiliser uniquement à l'intérieur d'une seule fonction, mais n'ont que valeur de pointeur préservés entre les appels de fonction. Je peux de nouveau utiliser le mot-clé "statique pour indiquer que l'objet est statique de la mesure; la mémoire est allouée au démarrage du programme et n'a été publié qu'à la fin du programme, l'objet de valeur sera conservée entre les appels de fonction.

/** 
 * foo.h
 */
#ifndef FOO_H
#define FOO_H

/**
 * Non-defining declaration of aGlobalPointer; makes the name available
 * to other translation units, but does not allocate the pointer object
 * itself.
 */
extern int *aGlobalPointer;

/**
 * A function that uses all three pointers (extern on a function 
 * declaration serves roughly the same purpose as on a variable declaration)
 */
extern void demoPointers(void);
...
#endif

/**
 * foo.c
 */
#include "foo.h"

/**
 * Defining declaration for aGlobalPointer.  Since the declaration 
 * appears at file scope (outside of any function) it will have static 
 * extent (memory for it will be allocated at program start and released 
 * at program end), and the name will be exported to the linker.
 */
int *aGlobalPointer;

/**
 * Defining declaration for aLocalPointer.  Like aGlobalPointer, it has 
 * static extent, but the presence of the "static" keyword prevents 
 * the name from being exported to the linker.  
 */
static int *aLocalPointer;

void demoPointers(void)
{
  /**
   * The static keyword indicates that aReallyLocalPointer has static extent, 
   * so the memory for it will not be released when the function exits,
   * even though it is not accessible outside of this function definition
   * (at least not by name)
   */
  static int *aReallyLocalPointer;
}

OriginalL'auteur John Bode

2

réponse courte.
Statique est persistant, de sorte que si vous déclarez dans une fonction, lorsque vous appelez la fonction de nouveau la valeur est la même que la dernière fois. Si vous déclarez à l'échelle mondiale, il est seul dans ce fichier.

Extern signifie qu'il a déclaré l'échelle mondiale, mais dans un autre fichier. (cela signifie essentiellement cette variable n'existe pas et c'est ce que ses définie comme).

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.