Superioriteit van naamruimte boven statische?

Hoe zijn naamruimten zonder naam superieur aan het staticzoekwoord?


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. staticfuncties zijn standaardniet langer verouderd!

Niettemin zijn naamloze namespace‘s superieur aan het statische sleutelwoord, voornamelijk omdat het sleutelwoord staticalleen 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 namespacesuperieur 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 statictrefwoord of naamloze namespacegebruikt 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 staticzijn voor de module, omdat staticniet echt verwijst naar de module, maar naar het bronbestand(vertaaleenheid). Je bent gedwongen om ze niet-staticte 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 namespacezou 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 namespaceprivateis, 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.

Other episodes