Quelle est la différence entre le vide inline statique et le vide?

static signifie qu'il ne peut pas être référencé à partir d'une autre unité de compilation (fichier source). "Référencé" signifie appelé, ou autrement appelé par son nom, par exemple, attribué à un pointeur de fonction.

inline est une allusion au compilateur que la fonction de code doit être généré inline à l'endroit où il est appelé, plutôt que généré comme une fonction distincte pour être ramifiés. Ceci est normalement fait pour des raisons de performances. D'accord avec Microsoft citation de:

le compilateur ne pas incorporer une fonction si son adresse est prise ou si elle est
trop grande à en ligne.

Une fonction inline n'a pas d'adresse, puisqu'elle n'existe pas comme une entité distincte. Son code est juste entrelacés de façon transparente avec le code il est appelé à partir. Donc, si vous prenez l'adresse d'une fonction (par exemple, pour attribuer à un pointeur), alors que le compilateur doit générer une fonction réelle, et ne peut pas l'inclure.

void signifie que la fonction ne retourne pas de valeur.

Avoir regardé l'exemple de code, je suppose qu'il y a une définition distincte de CGauss() quelque part, qui est appelé à partir d' fichier1.calors que fichier2.c est l'appel de sa propre version. Soit ça, ou fichier1.c est #includeing fichier2.c. Ce qui serait méchant.

Le mot-clé static

La définition d'une fonction C statique signifie (comme les docs disent) que cette fonction ne peut être accessible à partir du fichier source, il est défini. Le terme "référence" dans ce sens signifie soit l'appel de cette fonction ou, par exemple, en prenant un pointeur de fonction.

Inline

Normalement, lorsque vous écrivez une fonction en C, le compilateur génère du code machine pour cette fonction:

foo:
   /* some machine code */
   ret

Chaque fois que vous appelez cette fonction, le compilateur insère une instruction comme

  call <foo>

en l'appelant du code machine, ce qui ne signifie rien d'autre que de "sauter à toto, exécuter ce que vous y trouvez et lorsque vous rencontrez une instruction ret, de retour à cet endroit."

En revanche, pour les fonctions inline, le compilateur ne génère pas de séparer la fonction foo(), mais au lieu de cela insère le code machine pour la fonction foo dans chaque site d'appel. Lors de l'exécution de ce code, cela a le même effet.

Alors, pourquoi faisons-nous cela? Inline code a l'avantage de l'économie vous deux sauts (l'appel et les ret), ce qui rend votre code d'exécuter un peu plus vite. Comme un inconvénient, votre code devient plus grand, parce que vous insérez le code de l'ordinateur sur chaque site d'appel au lieu d'avoir une seule copie d'une fonction appelable. C'est pourquoi vous avez généralement de petites fonctions inline.

Aussi, vous ne pouvez pas prendre des pointeurs de fonction pour les fonctions inline et de mise au point devient plus difficile, parce que vous ne pouvez pas définir un point d'arrêt sur une fonction en ligne facilement.

Par conséquent, d'inlining est à gauche pour le compilateur comme une option d'optimisation, et en utilisant un mot-clé tel que C++en ligne, votre inline directive, ou de GCC __attribut((inline)), de vous donner uniquement le compilateur un soupçon que l'in-lining peut être vaut la peine d'essayer ici.

Je voudrais ajouter à tout ce qui précède, avant de lire ce qui précède, il est important de comprendre comment la programmation en c fonctionne.
Si vous écrivez simplement ouvrir le code, comme les

Setup(){
    int MainVar
}

MyRoutine(){
   int myVar1;
   int myVar2;
   bool myVar3;
   //Do stuff with myVars
   MainVar = myVar1 - myVar2;
   myVar3 = true;
}

Alors n'importe qui peut accéder à MyRoutine.myVar1 directement à partir d'un deuxième programme. Ils pourraient modifier la valeur de myVar2, (1. si elle n'est pas protégée, 2. si ils savent qu'il est là, 3. si ils savent ce qu'il fait) avant de l'utiliser dans MyRoutine //Faire quelque chose, et donc de changer ce que l'original programmeur prévu.

Imaginez que vous écrivez un programme bancaire, et à gauche le code vulnérable, alors quelqu'un pourrait modifier la valeur de la CAUTION, sans modifier le RETRAIT de l'autre rive dans votre routine. Quelqu'un pourrait venir le long et écrire un programme distinct pour modifier cette valeur par 2, ou 10, et de créer de l'argent là où il n'en existait pas. Mais si vous faites précéder le code, la routine, la méthode, ou les variables STATIQUES de Ces éléments ne peuvent pas être consultées et, surtout, modifié par un autre programme.

Vous pouvez utiliser Statique, à tout moment, ce qui fait toute routines FERMÉ, ou des variables individuelles uniquement FERMÉ. Ainsi, en permettant à d'autres d'apporter des modifications à certains aspects de votre code, mais en préservant les aspects qui ont besoin d'être protégés.

Mettre Statique à MyRoutine permettrait d'empêcher quelqu'un de s'exécuter MyRoutine à partir d'un autre programme. Depuis MyVars sont déclarés dans MyRoutine, ils ne seraient pas accessibles à partir d'un autre programme. Mais s'il y a une variable appelée MainVar déclaré ailleurs dans le programme, il serait accessible.

Setup(){
    int MainVar  //This can be accessed from outside this code
}

static MyRoutine(){  //Because of static these vars are not
   int myVar1;
   int myVar2;
   bool myVar3;
   //Do stuff with myVars
   MainVar = myVar1 - myVar2;
   myVar3 = true;
}

Et ici, uniquement les variables statiques sont protégés. myVar3 de pouvoir le lire par ailleurs d'informer une autre routine que l'échange est terminé.

Setup(){
    int MainVar    //This can be accessed from outside this code
}

MyRoutine(){
   static int myVar1;  //This can NOT be accessed from outside this code
   static int myVar2;  //This can NOT be accessed from outside this code
   bool myVar3;        //This can be accessed from outside this code
   //Do stuff with myVars
   MainVar = myVar1 - myVar2;
   myVar3 = true;
}