Co wymaga ode mnie deklaracji "using namespace std;"?

Question

To pytanie może być duplikatem, ale nie mogę znaleźć dobrej odpowiedzi. Krótkie i proste, co wymaga ode mnie zadeklarowania w programach C++, aby móc zadeklarować

Answer 1

Ponieważ ++ standard C została przyjęta, praktycznie wszystkie biblioteki standardowej jest wewnątrz przestrzeni nazw std. Jeśli więc nie chcesz kwalifikować wszystkich wywołań biblioteki standardowej za pomocą std::, musisz dodać dyrektywę using.

Jednak

using namespace std; 

jest uważane za złą praktyką, ponieważ są praktycznie cały importowania nazw standardowych, otwierając w ten sposób wiele możliwości nazwy starć. Lepiej jest importować tylko rzeczy używanemu w rzeczywistości w kodzie, jak

using std::string; 

Answer 2

Nic nie robi, to jest skrótem uniknąć poprzedzając wszystko w tej przestrzeni nazw z std ::

Answer 3

Możliwość odnoszą się do członków w przestrzeni nazw std bez potrzeby odwoływania się do std::member wyraźnie. Na przykład:

#include <iostream> 
using namespace std; 

... 
cout << "Hi" << endl; 

vs.

#include <iostream> 

... 
std::cout << "Hi" << std::endl; 

Answer 4

Przede wszystkim nie jest to wymagane w C - C nie mają nazw. W C++, wszystko w przestrzeni nazw std, które obejmuje większość biblioteki standardowej. Jeśli nie to zrobić trzeba uzyskać dostęp do członków nazw wyraźnie tak:

std::cout << "I am accessing stdout" << std::endl; 

Answer 5

Wszystkie pliki w folderze C++ biblioteki standardowej deklarować wszystkich swoich jednostek w przestrzeni nazw std.
np: Aby korzystać cin,cout zdefiniowane w iostream

Alternatywy:

using std::cout; 
using std::endl; 
cout << "Hello" << endl;

std::cout << "Hello" << std::endl;

Answer 6

jest używany, gdy używasz coś, co jest zadeklarowane w przestrzeni nazw. Biblioteka standardowa C++ jest zadeklarowana w standardowej przestrzeni nazw. Dlatego trzeba zrobić

using namespace std; 

chyba że chcesz określić obszar nazw podczas wywoływania funkcji w innej przestrzeni nazw, tak jak poniżej:

std::cout << "cout is declared within the namespace std"; 

Możesz przeczytać więcej na ten temat na http://www.cplusplus.com/doc/tutorial/namespaces/.

Answer 7

Po pierwsze, dyrektywa using nigdy nie jest wymagana w C, ponieważ C w ogóle nie obsługuje przestrzeni nazw.

nigdy faktycznie Dyrektywa using jest wymagane w C++, ponieważ każdy z elementów znajdujących się w przestrzeni nazw można uzyskać bezpośrednio poprzedzając je std:: zamiast. Tak więc, na przykład:

using namespace std; 
string myString; 

odpowiada:

std::string myString; 

, czy zdecydujesz się go użyć, jest kwestią wyboru, ale naraża całą std nazw zaoszczędzić kilka klawiszy jest na ogół uważane za złą formę. Alternatywną metodą, która eksponuje tylko poszczególne elementy w przestrzeni nazw jest następująca:

using std::string; 
string myString; 

To pozwala wystawiać tylko elementy w std nazw, które szczególnie potrzebują, bez ryzyka narażania nieumyślnie coś ty nie zamierzać.

Answer 8

Nigdy nie musisz zadeklarować używając przestrzeni nazw std; stosując to jest złą praktyką i należy użyć std :: jeśli nie chcesz pisać std :: zawsze można zrobić coś takiego w niektórych przypadkach:

using std::cout; 

Używając std :: można również powiedz, która część twojego programu używa standardowej biblioteki, a która nie. Co jest jeszcze ważniejsze, że mogą pojawić się konflikty z innymi funkcjami, które zostaną uwzględnione.

Rgds Layne

Answer 9

Nie należy zdecydowanie powiedzieć:

using namespace std; 

w nagłówkach C++, bo bije cały punkt przy użyciu przestrzeni nazw (robi to stanowiłoby "zanieczyszczenie przestrzeni nazw"). Kilka przydatnych zasobów na ten temat są następujące: gwint

1) stackoverflow na Standard convention for using “std”

2) artykuł Herb Sutter na Migrating to Namespaces

3) FAQ 27.5 z Marshall Cline na C++ FAQ Lite.

Answer 10

Przestrzenie nazw są sposobem na zawijanie kodu w celu uniknięcia pomyłek i sprzecznych nazw. Na przykład:

common1.h Plik:

namespace intutils 
{ 
    int addNumbers(int a, int b) 
    { 
     return a + b; 
    } 
} 

wykorzystanie pliku:

#include "common1.h"  
int main() 
{ 
    int five = 0; 
    five = addNumbers(2, 3); // Will fail to compile since the function is in a different namespace. 
    five = intutils::addNumbers(2, 3); // Will compile since you have made explicit which namespace the function is contained within. 

    using namespace intutils; 
    five = addNumbers(2, 3); // Will compile because the previous line tells the compiler that if in doubt it should check the "intutils" namespace. 
} 

Więc kiedy piszesz using namespace std wszystko robisz mówi kompilatorowi, że w razie wątpliwości powinien wyglądać w przestrzeni nazw std dla funkcji itp., dla których nie można znaleźć definicji. Jest to powszechnie stosowane w przykładowym (i produkcyjnym) kodzie, ponieważ sprawia, że ​​pisanie popularnych funkcji itp., Takich jak cout, jest szybsze niż konieczność pełnej kwalifikacji każdego z nich jako std::cout.

Answer 11

Z technicznego punktu widzenia może być wymagane użycie przy użyciu (w przypadku całych przestrzeni nazw lub pojedynczych nazw), aby móc korzystać z wyszukiwania zależnego od argumentu.

Rozważ dwie następujące funkcje, które używają swap().

#include <iostream> 
#include <algorithm> 

namespace zzz 
{ 
    struct X {}; 


void swap(zzz::X&, zzz::X&) 
{ 
    std::cout << "Swapping X\n"; 
} 
} 

template <class T> 
void dumb_swap(T& a, T& b) 
{ 
    std::cout << "dumb_swap\n"; 
    std::swap(a, b); 
} 

template <class T> 
void smart_swap(T& a, T& b) 
{ 
    std::cout << "smart_swap\n"; 
    using std::swap; 
    swap(a, b); 
} 

int main() 
{ 
    zzz::X a, b; 
    dumb_swap(a, b); 
    smart_swap(a, b); 

    int i, j; 
    dumb_swap(i, j); 
    smart_swap(i, j); 
} 

dumb_swap zawsze wywołuje std::swap - choć wolelibyśmy użyciu zzz::swap dla zzz::X obiektów.

smart_swap sprawia std::swap widoczny jako wybór upadek do tyłu (na przykład, gdy nazywa się int), ale ponieważ nie w pełni kwalifikują się nazwę, zzz::swap zostaną wykorzystane przez ADL dla zzz::X.

---

subiektywnie, co zmusza mnie do korzystania using namespace std; jest pisanie kodu, który wykorzystuje wszystkie rodzaje standardowych obiektów funkcyjnych itd

//copy numbers larger than 1 from stdin to stdout 
remove_copy_if(
    std::istream_iterator<int>(std::cin), std::istream_iterator<int>(), 
    std::ostream_iterator<int>(std::cout, "\n"), 
    std::bind2nd(std::less_equal<int>(), 0) 
); 

IMO, w kodzie tak std:: właśnie sprawia, że ​​hałas linii.

Nie znajdę w takich przypadkach using namespace std; haniebnej zbrodni, jeśli jest używana w pliku implementacji (ale może być nawet ograniczona do zakresu funkcji, jak w przykładzie zamiany).

Zdecydowanie nie umieszczaj instrukcji using w plikach nagłówkowych. Powodem tego jest to, że zanieczyszcza przestrzeń nazw dla innych nagłówków, które mogą być zawarte po naruszeniu, potencjalnie prowadząc do błędów w innych nagłówkach, które mogą nie być pod twoją kontrolą. (Dodaje również czynnik zaskoczenia: osoby, w tym plik, mogą nie oczekiwać widocznych nazw wszystkich rodzajów).

Answer 12

Nic, co musisz zrobić pod - chyba że jesteś implementatorem C++ Standard Library i chcesz unikaj powielania kodu podczas deklarowania plików nagłówków w stylu "nowym" i "starym":

// cstdio 
namespace std 
{ 
    // ... 
    int printf(const char* ...); 
    // ... 
} 

.

// stdio.h 
#include <cstdio> 
using namespace std; 

Cóż, oczywiście przykładem jest nieco wymyślony (można równie dobrze używać zwykłego <stdio.h> i umieścić ją całą w std w <cstdio>), ale Bjarne Stroustrup pokazuje ten przykład w jego .