Salut, je regardais des codes sources C++ et n´étant pas très avancé dans la programmation en C++, je me demandais ce que faisais l´opérateur de résolution de portée en début de ligne?

hTh[0] = ::CreateThread (0, 1, Lecteur, &op, 0, &idTh[0]);

Je croyais que cet opérateur devait être précédé de quelque chose.. dans quelle situation peut-on l´utiliser ainsi?

Tu peux l´utiliser dans cette situation :

1. include <iostream>

using namespace std;

int cactus = 42;

int main(void)
{

int cactus = 44;

/* on accède à l´espace de nom global */
cout << "global : " << ::cactus;

/* on accède à l´espace de nom local */
cout << "local : " << cactus;

return 0;
}

si tu as quelque chose devant le :: genre std::cout c´est pour spécifier de quel espace de nom (namespace) il s´agit. C´est d´ailleurs pour raccourcir std::cout en cout que l´on emploie ´using namespace std´

Tournée dans un autre sens, imaginons le cas suivant :

1. include <iostream>

using namespace std;

class Guybrush {

static string starter = "Once upon a time, in a galaxy not so far away"
};

int main(void)
{
string Guybrush = " God said #Pentacles Mayhem ca rox# ";
cout << starter << Guybrush::starter ;

return 0;
}

Ok donc en fait, dans le premier cas, c´est un "casseur de priorité"?

pas vraiment un "casseur de priorité", en fait, ça permet de "ressortir", moi je le vois un peu comme une arborescence de fichiers :

Imagine tu as un fichier a.txt dans la racine de ton disque C:\, et un fichier a.txt dans un repertoire C:\PLOUF

--- tu es dans la racine :
- pour avoir a.txt, tu demandes a.txt
- pour avoir plouf\a.txt tu demandes plouf\a.txt

--- tu es dans plouf :
- pour avoir plouf\a.txt tu demandes a.txt (tu es dans plouf)
- pour avoir a.txt de la racine, tu demandes ..\a.txt

Tu vois l´analogie ? le ::truc est un peu la meme chose que le ..\truc dans les disques, il sert a aller chercher le contexte global plutot que de prendre le contexte local.

Sauf que cen´est pas vraiment un .. dans une arborescence mais plutôt le C:\ ou le / sous nix, c´est-à-dire que ça te fait remonter tout en haut et pas juste d´un niveau :

int a = 5;
namespace A
{
int a = 10;
namespace B
{
int a = 20;
int f()
{ return ::a + a;; }
}
}
A.B.f() renverra 25 (20 + 5) et non pas 30. Il n´y a pas moyen d´accéder au a intermédiaire sans repasser par la racine (avec A.a, ou ::A.a).

A noter que sous les bons IDE (par exemple Visual Studio, je n´en connait pas d´autre qui ont cette fonctionnalité), quand tu tape :: tu active la complétion automatique et il te propose tout les noms qui sont dans l´espace de nommage global. Ça peut être pratique parfois.