Que fait l'opérateur :: dans cette situation

#include <iostream>

int main()
{
   std::cout << "hi!\n";  // access the object 'cout' in the namespace 'std'
}

Alors j'aurais peut-être compris que

Je suggère fortement d ' apprendre C ++ à partir d'un livre, et d'apprendre à utiliser le matériel de référence existant, plutôt que d'essayer de comprendre ce que signifie un code à partir des premiers principes. Vous risquez très probablement de faire des erreurs subtiles si vous faites des suppositions éclairées.

L'expression Factorielle :: value est un identifiant qualifié .

Factorial code> est le nom d'une classe (une instanciation du modèle Factorial avec une valeur spécifique pour le paramètre unique). Cette classe a un membre de données appelé valeur . Une qualification explicite est nécessaire car cette valeur particulière n'est pas autrement dans la portée. Voir aussi recherche de nom qualifié .

Vous pouvez utiliser :: comme ceci pour n'importe quel membre de classe: par exemple std :: string :: npos signifie approximativement trouver le membre de données appelé npos dans la classe appelée string dans l'espace de noms appelé std.

... en quelque sorte alimenter / ajouter dans la variable 'value' le contenu de l'opération effectuée précédemment ...

il n'y a pas de "plus tôt", tout se passe au cours de la même étape de compilation.

Par exemple, je peux écrire manuellement

struct F_0 { static const int value = 1; }
struct F_1 { static const int value = 1 * F_0::value; }
struct F_2 { static const int value = 2 * F_1::value; }
struct F_3 { static const int value = 3 * F_2::value; }

etc. etc. pour autant de valeurs que je veux. La version basée sur un modèle est effectivement la même mais économise beaucoup de frappe.

Plus précisément, l'écriture de Factorial instancie le modèle Factorial pour N = 3 , ce qui signifie que nous avons maintenant une classe concrète non-template Factorial équivalente au F_3 code> J'ai écrit manuellement ci-dessus.

La définition de cette classe fait référence à Factorial :: value (avec N-1 = 2 code >), donc Factorial est également instancié. Cette chaîne d'instanciations implicites continue jusqu'à ce que nous atteignions le Factorial explicitement spécialisé (sans cela, il continuerait à essayer d'instancier Factorial , Factorial , pour toujours jusqu'à ce que le compilateur abandonne et échoue).

L'opérateur ':: -' est utilisé pour accéder aux choses dans les espaces de noms (std :: string) ou aux choses statiques dans une classe:

struct C {
    static int i = 42;
};
int main() {
    std::cout << C::i << '\n';
}

Ici C :: i est statique, donc Je n'ai pas besoin d'une instance de la classe C. Pour accéder à quelque chose non statique dans une classe, vous utilisez un «.». Dans votre exemple, Factorial n'est pas une classe mais un modèle, Factorial est une classe et Factorial :: value est la valeur statique int à l'intérieur de la classe Factorial.

Pour rendre cela plus clair, envisagez un accès alternatif à l'élément de données value.

479001600

La sortie du programme est

#include <iostream>

template <int N>
struct Factorial {
  static const int value = N * Factorial<N - 1>().value;
};

// Base case via template specialization:

template <>
struct Factorial<0> {
  static const int value = 1;
};

int main()
{
    std::cout << Factorial<12>().value << '\n';
}