ARCHIV

C/C++ (38) - Prostory jmen potřetí

Minule jsme céčkovským motivačním příkladem poněkud odbočili, dnes se opět vrátíme k výkladu syntaxe namespace v jazyce C++.

26.7.2006 06:00 | Jan Němec | Články autora | přečteno 18486×

Anonymní namespace

Prostor jmen nemusí mít explicitně uvedené jméno. Lze tedy zapsat i

namespace {
  int i;
}

Namespace bez uvedeného jména se nazývá anonymní a je mu vnitřně překladačem přidělen nějaký identifikátor. Tento identifikátor ovšem závisí na souboru, v němž je namespace umístěno. V rámci jednoho souboru potom můžeme i mimo prostor jmen používat identifikátory z anonymního namespace tak, jako by to byly běžné identifikátory. Z jiných zdrojových souborů naopak budou nedostupné a to i z v nich umístěných jiných anonymních namespace. Jedná se tedy jen o jakousi obdobu globálních static identifikátorů ve stylu C. Přiznám se, že osobně preferuji i v C++ static identifikátory před anonymním prostorem jmen. Ukažme si použití anonymního namespace na příkladu.

/* namespace.cpp */
namespace {
  // identifikátor z namespace
  int i = 0;

  int f(void) {
    // použití identifikátoru z toho samého namespace, OK
    return i;
  }
}

namespace {
  int f2(void) {
    // použití identifikátoru z jiné části toho samého namespace, OK
    return i;
  }
}

namespace neanonymni {
  int f3(void) {
    // použití identifikátoru z jiného namespace, OK
    return i;
  }
}

int main(void) {
  // použití identifikátoru mimo namespace, OK
  return i;
}

Zatím nám vše prošlo, příklad bude fungovat. Pokud se ovšem pokusíme použít identifikátor i v jiném souboru, nebudeme úspěšní.

/* chyba.cpp */
namespace { 
  // Je jedno, zda extern deklaraci a použití i dáme do namespace nebo ne
  extern int i;
}

int f4(void) {
  return i;
}

Pokusme se projekt přeložit:

$ g++ namespace.cpp chyba.cpp
/home/honza/tmp/ccLjwuDX.o: In function `f4()':
chyba.cpp:(.text+0x4): undefined reference to `(anonymous namespace)::i'
collect2: ld returned 1 exit status
$

Došlo k chybě při linkování neboť jsem se pokoušel přistupovat k identifikátoru z anonymního namespace z jiného souboru. Zapamatujme si tedy, že anonymní namespace je záležitostí lokální v rámci jednoho souboru.

Aliasy

Z předminulého dílu víme, že prostory jmen můžeme do sebe zanořovat podobně jako například adresáře. Pokud často používáme hluboko zanořený adresář, zpravidla si na něj vytvoříme jednoduchý odkaz, link. Na úrovni namespace se tomu říká alias.

namespace vnejsi {
  namespace stredni {
    namespace vnitrni {
      int identifikator = 0;
    }
  }
}

namespace vsv = vnejsi::stredni::vnitrni;

int main(void) {
  return vsv::identifikator;
}

using identifikátor

Pokud opakovaně spouštíme jediný konkrétní soubor uložený kdesi hluboko v adresářové struktuře mimo dosah proměnné PATH, vytvoříme si link jen přímo na něj nebo napíšeme jednoduchý spouštěcí skript a umístíme jej třeba do /usr/bin nebo jiného oblíbeného adresáře. Cestu ve volání souboru pak můžeme vynechávat. V případě C++ namespace použijeme v té samé situaci klíčové using s parametrem plně kvalifikovaného identifikátoru. Od deklarace using dál pak můžeme ve zdrojovém souboru používat identifikátor i bez jména namespace.

namespace HrozneDlouhyNazev {
  int i = 0;
}

using HrozneDlouhyNazev::i;

int main(void) {
  return i;
}

using namespace

Někdy bychom potřebovali opakovaně spouštět větší množství souborů z nějakého zanořeného adresáře. V tom případě obvykle přidáme příslušný adresář do proměnné PATH. Analogickou situaci v C++ vyřešíme opět pomocí using, jeho parametrem bude teď celý prostor jmen a nikoli pouze jediný identifikátor.

namespace HrozneDlouhyNazev {
  int i = 0;
  int j = 0;
}

using namespace HrozneDlouhyNazev;

int main(void) {
  return i + j;
}

Direktiva using namespace n1 nemusí zpřístupňovat identifikátory pouze n1. Pokud totiž toto namespace obsahuje kromě identifikátoru ještě i další direktivu using namespace n2, přenese se viditelnost i na identifikátory z n2. Říkáme, že using je tranzitivní, překladač musí při vyhodnocování přístupnosti identifikátoru projít celý strom using závislostí namespace.

namespace n2 {
  int i = 0;
}

namespace n1 {
  using namespace n2; 
  int j = 0;
}

using namespace n1;

int main(void) {
  // OK, i známe díky tranzitivitě using
  return i + j;
}

Snadno může nastat situace, kdy si prostřednictvím using buď přímo, nebo prostřednictvím tranzitivity zpřístupníme dva různé identifikátory stejného jména z různých namespace. To samo o sobě ještě není chyba, pouze nemůžeme takovýto identifikátor použít bez úplné kvalifikace.

namespace n2 {
  int i = 0;
}

namespace n1 {
  using namespace n2; 
  int i = 0;
}

using namespace n1;

int main(void) {
  // Chyba, které i? Správně je return n2::i; nebo return n1::i;
  return i;
}

Zábavná je v tomto případě chybová hláška mého g++ 4.0.1, překladač se pro jistotu tváří, že identifikátor i vůbec nezná.

error: 'i' was not declared in this scope

namespace std a standardní knihovna C a C++

Celá standardní knihovna jazyka C++ je umístěna v prostoru jmen std. Běžně se tak setkáme s konstrukcemi typu using namespace std, using std::string, std::vector a podobně. C++ se navíc snaží být v maximální možné míře "zpětně" kompatibilní s C (již víme, že z 99% se mu to daří - rozumně napsaný kód v C lze přeložit i překladačem C++ při zachování funkčnosti), musí proto obsahovat i kompletní standardní knihovnu jazyka C. Kdyby byla umístěna do prostoru std, utrpěla by kompatibilita s C. Umístění v globálním prostoru jmen by zase narušilo konzistenci návrhu C++. Řešení je šalamounské: pro každý standardní hlavičkový soubor jazyka C přidá C++ jeho dvojníka bez přípony .h a s prefixem c. Původní header zpřístupňuje identifikátory v globálním prostoru jmen (tak jako v C) a modifikovaný v std. Následující dva hello world příklady jsou tedy ekvivalentní. Začneme tím ve stylu C.

#include <stdio.h>

int main(void) {
  puts("Ahoj světe!");
  return 0;
}

A ve stylu C++ (byť s použitím C funkce).

#include <cstdio>

int main(void) {
  std::puts("Ahoj světe!");
  return 0;
}

Samozřejmě nesmíme oba přístupy míchat, tj. inkludovat *.h header a používat identifikátory se std:: nebo naopak. Bohužel, překladače podobné chování často tolerují.

Domácí úkoly

• Podívejte se do zdrojového kódu vaší oblíbené open source knihovny nebo aplikace napsané v C++. Používá namespace? Pokud ne, nenechte se tím odradit.
• Zkuste v C++ smíchat dohromady inkludy tradičních a C++ headerů pro standardní knihovnu C. Chvíli používejte namespace std a chvíli ne. Zkuste, co váš překladač bude tolerovat. Nejsíš víc, než by podle normy měl.

Pokračování příště

V příštím dílu se zamyslíme nad objektově orientovaným programováním.

Verze pro tisk