Hoe zijn naamruimten zonder naam superieur aan het static
zoekwoord?
Antwoord 1, autoriteit 100%
U verwijst in feite naar de sectie §7.3.1.1/2 van de C++03 Standard,
Het gebruik van het statische sleutelwoord is
verouderd bij het declareren van objecten in a
naamruimte bereik; de
unnamed-namespace biedt een superieur
alternatief.
Merk op dat deze paragraaf al is verwijderd in C++11. static
functies zijn standaardniet langer verouderd!
Niettemin zijn naamloze namespace
‘s superieur aan het statische sleutelwoord, voornamelijk omdat het sleutelwoord static
alleen van toepassing is op de variabelendeclaraties en functies , niet voor de door de gebruiker gedefinieerde typen.
De volgende code is geldig in C++:
//legal code
static int sample_function() { /* function body */ }
static int sample_variable;
Maar deze code is NIET geldig:
//illegal code
static class sample_class { /* class body */ };
static struct sample_struct { /* struct body */ };
Dus de oplossing is, naamloos (ook wel anoniem) namespace
, en dat is dit:
//legal code
namespace
{
class sample_class { /* class body */ };
struct sample_struct { /* struct body */ };
}
Hoop dat het verklaart waarom naamloze namespace
superieur is aan static
.
Houd er ook rekening mee dat het gebruik van een statisch sleutelwoord wordt afgeraden bij het declareren van objecten in een naamruimtebereik (volgens de standaard).
Antwoord 2, autoriteit 7%
Hieraan is een interessant probleem gerelateerd:
Stel dat u een static
trefwoord of naamloze namespace
gebruikt om een interne functie in de module te maken (vertaaleenheid), aangezien deze functie bedoeld is om intern door de module te worden gebruikt en daarbuiten niet toegankelijk. (Naamloze namespace
‘s hebben het voordeel dat ze naast functies ook gegevens en typedefinities intern maken.
Na verloop van tijd wordt het bronbestand van de implementatie van uw module groter en u wilt het opsplitsen in verschillende afzonderlijke bronbestanden, zodat u de code beter kunt organiseren, de definities sneller kunt vinden en onafhankelijk kunt compileren.
Maar nu heb je een probleem: die functies kunnen niet langer static
zijn voor de module, omdat static
niet echt verwijst naar de module, maar naar het bronbestand(vertaaleenheid). Je bent gedwongen om ze niet-static
te maken om ze toegankelijk te maken vanuit andere delen (objectbestanden) van die module. Maar dit betekent ook dat ze niet langer verborgen/privé zijn voor de module: omdat ze een externe link hebben, zijn ze toegankelijk vanuit andere modules, wat nietje oorspronkelijke bedoeling was.
Naamloze namespace
zou dit probleem ook niet oplossen, omdat het ook is gedefinieerd voor een bepaald bronbestand (vertaaleenheid) en niet van buitenaf toegankelijk is.
Het zou geweldig zijn als men zou kunnen specificeren dat een namespace
private
is, dat wil zeggen, wat er ook in gedefinieerd is, bedoeld is om intern door de module te worden gebruikt hoort bij. Maar natuurlijk heeft C++ niet zo’n concept als “modules”, alleen “vertaaleenheden”, die nauw verbonden zijn met de bronbestanden.