Using namespace std не работает

Почему с using namespace std; может быть очень плохо

То, что написано ниже, для многих квалифицированных C++ разработчиков будет прекрасно известным и очевидным, но тем не менее, я периодически встречаю using namespace std; в коде различных проектов, а недавно в нашумевшей статье про впечатления от высшего образования было упомянуто, что студентов так учат писать код в вузах, что и сподвигло меня написать эту заметку.

Итак. многие слышали, что using namespace std; в начале файла в C++ считается плохой практикой и нередко даже явно запрещен в принятых во многих проектах стандартах кодирования. Касательно недопустимости использования using namespace в header-файлах вопросов обычно не возникает, если мы хоть немного понимаем, как работает препроцессор компилятора: .hpp-файлы при использовании директивы #include вставляются в код «как есть», и соответственно using автоматически распространится на все затронутые .hpp- и .cpp-файлы, если файл с ним был заинклюден хоть в одном звене цепочки (на одном из сайтов это метко обозвали «заболеванием передающимся половым путем«). Но вот про .cpp-файлы все не так очевидно, так что давайте еще раз разберем, что же именно здесь не так.

Для чего вообще придумали пространства имен в C++? Когда какие-то две сущности (типы, функции, и т.д.) имеют идентификаторы, которые могут конфликтовать друг с другом при совместном использовании, C++ позволяет объявлять пространства с помощью ключевого слова namespace. Всё, что объявлено внутри пространства имен, принадлежит только этому пространству имен (а не глобальному). Используя using мы вытаскиваем сущности какого-либо пространства имен в глобальный контекст.

А теперь посмотрим, к чему это может привести.

Допустим, вы используете две библиотеки под названием Foo и Bar и написали в начале файла что-то типа

. таким образом вытащив всё, что есть в foo:: и в bar:: в глобальное пространство имен.

Все работает нормально, и вы можете без проблем вызвать Blah() из Foo и Quux() из Bar. Но однажды вы обновляете библиотеку Foo до новой версии Foo 2.0, которая теперь еще имеет в себе функцию Quux().

Теперь у вас конфликт: и Foo 2.0, и Bar импортируют Quux() в ваше глобальное пространство имен. В лучшем случае это вызовет ошибку на этапе компиляции, и исправление этого потребует усилий и времени.

А вот если бы вы явно указывали в коде метод с его пространством имен, а именно, foo::Blah() и bar::Quux(), то добавление foo::Quux() не было бы проблемой.

Но всё может быть даже хуже!

В библиотеку Foo 2.0 могла быть добавлена функция foo::Quux(), про которую компилятор по ряду причин посчитает, что она однозначно лучше подходит для некоторых ваших вызовов Quux(), чем bar::Quux(), вызывавшаяся в вашем коде на протяжении многих лет. Тогда ваш код все равно скомпилируется, но будет молча вызывать неправильную функцию и делать бог весть что. И это может привести к куче неожиданных и сложноотлаживающихся ошибок.

Имейте в виду, что пространство имен std:: имеет множество идентификаторов, многие из которых являются очень распространенными (list, sort, string, iterator, swap), которые, скорее всего, могут появиться и в другом коде, либо наоборот, в следущей версии стандарта C++ в std добавят что-то, что совпадет с каким-то из идентификаторов в вашем существующем коде.

Если вы считаете это маловероятным, то посмотрим на реальные примеры со stackoverflow:

Вот тут был задан вопрос о том, почему код возвращает совершенно не те результаты, что от него ожидает разработчик. По факту там происходит именно описанное выше: разработчик передает в функцию аргументы неправильного типа, но это не вызывает ошибку компиляции, а компилятор просто молча использует вместо объявленной выше функции distance() библиотечную функцию std::distance() из std:: ставшего глобальным неймспейсом.

Второй пример на ту же тему: вместо функции swap() используется std::swap(). Опять же, никакой ошибки компиляции, а просто неправильный результат работы.

Так что подобное происходит гораздо чаще, чем кажется.

Источник

Проблема с using namespace std;

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Что использовать, std::cout или просто using namespace std?
Приветствую! Сейчас учу С++, постигаю азы так сказать. В арсенале две книги — Джефф Кент, .

Использовать using namespace std; или каждый раз прописывать std:: . ?
Как безопаснее и рациональнее поступать? Как в больших проектах поступают на этот счет?

Зачем часто писать std. если можно один раз using namespace std?
зачем часто писать std:: если можно один раз using namespace std?

Пространство имен — namespace std или std::
В каких случая лучше писать (std::cout) или просто прописать (namespace std) и почему ?

хз чего ты там понял.
это какой то непонятный наборк букв
ты сам понял, что как ты думаешь ты понял?

у тебя в коде заголовки кривые.
и возвращаемое значение для main забыл указать.

Std:: или using namespace std;
Вопрос к профессионалам. Меня давно интересуют такие вопросы: 1) Почему, многим, вроде бы не.

namespace std
Добрый день. Вычитал что могу использовать любой namespace. Но в другом месте написано что если.

Using namespace std
В чем отличие, если один cout (или что-то другое) будет в std, а другой stdd, для чего вообще using.

using namespace std;
Здравствуйте. Я заметил, что многие программисты стараются избегать этой строчки в своих.

Источник

Пространства имен (C++)

Пространство имен — это декларативная область, в рамках которой определяются различные идентификаторы (имена типов, функций, переменных, и т. д.). Пространства имен используются для организации кода в виде логических групп и с целью избежания конфликтов имен, которые могут возникнуть, особенно в таких случаях, когда база кода включает несколько библиотек. Все идентификаторы в пределах пространства имен доступны друг другу без уточнения. Идентификаторы за пределами пространства имен могут обращаться к членам с помощью полного имени для каждого идентификатора, например std::vector vec; , или else с помощью объявления using для одного идентификатора ( using std::string ) или директивы using для всех идентификаторов в пространстве имен ( using namespace std; ). Код в файлах заголовков всегда должен содержать полное имя в пространстве имен.

В следующем примере показано объявление пространства имен и продемонстрированы три способа доступа к членам пространства имен из кода за его пределами.

Использование полного имени:

Чтобы добавить в область видимости один идентификатор, используйте объявление using:

Чтобы добавить в область видимости все идентификаторы пространства имен, используйте директиву using:

директивы using

using Директива позволяет использовать все имена в namespace для использования без имени пространства имен в качестве явного квалификатора. Использование директивы using в файле реализации (т. е. *. cpp) при использовании нескольких различных идентификаторов в пространстве имен; Если вы используете только один или два идентификатора, рассмотрите использование объявления using, чтобы привести эти идентификаторы в область, а не все идентификаторы в пространстве имен. Если локальная переменная имеет такое же имя, как и переменная пространства имен, то переменная пространства имен будет скрытой. Создавать переменную пространства имен с те же именем, что и у глобальной переменной, является ошибкой.

Директиву using можно поместить в верхнюю часть CPP-файла (в области видимости файла) или внутрь определения класса или функции.

Без особой необходимости не размещайте директивы using в файлах заголовков (*.h), так как любой файл, содержащий этот заголовок, добавит все идентификаторы пространства имен в область видимости, что может вызвать скрытие или конфликты имен, которые очень трудно отлаживать. В файлах заголовков всегда используйте полные имена. Если эти имена получаются слишком длинными, используйте псевдоним пространства имен для их сокращения. (См. ниже.)

Объявление пространств имен и их членов

Как правило, пространство имен объявляется в файле заголовка. Если реализации функций находятся в отдельном файле, определяйте имена функций полностью, как показано в следующем примере.

Реализации функций в контосодата. cpp должны использовать полное имя, даже если поместить using директиву в начало файла:

Пространство имен может быть объявлено в нескольких блоках в одном файле и в нескольких файлах. Компилятор соединит вместе все части во время предварительной обработки и полученное в результате пространство имен будет содержать все члены, объявленные во всех частях. Примером этого является пространство имен std, которое объявляется в каждом из файлов заголовка в стандартной библиотеке.

Члены именованного пространства имен могут определяться за его границами, если они объявлены путем явной квалификации определяемого пространства имен. Однако определение должно располагаться после точки объявления в пространстве имен, окружающем то пространство имен, где находится объявление. Пример:

Эта ошибка может возникнуть, когда члены пространства имен объявляются в нескольких файлах заголовка и эти заголовки не включены в правильном порядке.

Глобальное пространство имен

Если идентификатор не объявлен явно в пространстве имен, он неявно считается входящим в глобальное пространство имен. В общем случае старайтесь не делать объявления в глобальной области, если это возможно, за исключением функции Mainточки входа, которая должна находиться в глобальном пространстве имен. Чтобы явно указать глобальный идентификатор, используйте оператор разрешения области видимости без имени, как сделано в ::SomeFunction(x); . Это позволит отличать данный идентификатор от любого другого элемента с таким же именем, находящегося в другом пространстве имен. Кроме того, это облегчит понимание кода.

Пространство имен std

Все типы и функции стандартной библиотеки C++ объявляются в std пространстве имен или пространствах имен, вложенных в std .

Вложенные пространства имен

Пространства имен могут быть вложенными. Обычное вложенное пространство имен имеет неполный доступ к членам родительского элемента, но родительские элементы не имеют неполного доступа к вложенному пространству имен (если только оно не объявлено как встроенное), как показано в следующем примере:

Обычные вложенные пространства имен можно использовать для инкапсуляции данных о внутренней реализации, которые не являются частью открытого интерфейса родительского пространства имен.

Встроенные пространства имен (C++ 11)

В отличие от обычных вложенных пространств имен члены встроенного пространства имен обрабатываются как члены родительского пространства имен. Эта особенность позволяет выполнять поиск перегруженных функций с зависимостью от аргументов среди функции, которые имеют перегрузки в родительском и вложенном встроенном пространстве имен. Это также позволяет объявлять специализации в родительском пространстве имен для шаблонов, объявленных во встроенном пространстве имен. В следующем примере показано, как внешний код привязывается к встроенному пространству имен по умолчанию.

В следующем примере показано, как можно объявить специализацию в родительском пространстве имен шаблона, объявленного во встроенном пространстве имен.

Встроенные пространства имен можно использовать как механизм управления версиями для управления изменениями в открытом интерфейсе библиотеки. Например, можно создать одно родительское пространство имен и инкапсулировать каждую версию интерфейса в своем собственном пространстве имен, вложенном в родительское. Пространство имен, которое содержит самую последнюю или основную версию, квалифицируется как встроенное и поэтому представляется так, будто оно является непосредственным членом родительского пространства имен. Клиентский код, вызывающий Parent::Class, автоматически привязывается к новому коду. Клиенты, которые предпочитают использовать старую версию, могут по-прежнему получить доступ к ней, используя полный путь к вложенному пространству имен, содержащему данный код.

Ключевое слово inline должно применяться к первому объявлению пространства имен в единице компиляции.

В следующем примере показано две версии интерфейса: каждое — во вложенном пространстве имен. Пространство имен v_20 содержит некоторые изменения из интерфейса v_10 и помечается как встроенное. Клиентский код, который использует новую библиотеку и вызывает Contoso::Funcs::Add , вызовет версию v_20. Код, который пытается вызвать Contoso::Funcs::Divide , теперь будет вызывать ошибку времени компиляции. Если действительно требуется эта функция, доступ к версии v_10 можно получить путем явного вызова Contoso::v_10::Funcs::Divide .

Псевдонимы пространств имен

Имена пространств имен должны быть уникальными, из-за чего зачастую они получаются не слишком короткими. Если длина имени затрудняет чтение кода или утомительно вводить файл заголовка, где нельзя использовать директивы using, можно создать псевдоним пространства имен, который служит аббревиатурой для фактического имени. Пример:

анонимные или безымянные пространства имен

Вы можете создать явное пространство имен, но не присвоить ему имя.

Это называется безымянным или анонимным пространством имен, и его можно использовать, если нужно сделать объявления переменных невидимыми для кода в других файлах (т. е. обеспечить их внутреннюю компоновку) без создания именованного пространства имен. Весь код, находящийся в том же файле, может видеть идентификаторы в безымянном пространстве имен, но эти идентификаторы, а также само пространство имен, будет невидимым за пределами этого файла или, точнее, вне блока перевода.

Источник

using namespace std

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Что использовать, std::cout или просто using namespace std?
Приветствую! Сейчас учу С++, постигаю азы так сказать. В арсенале две книги — Джефф Кент, .

Использовать using namespace std; или каждый раз прописывать std:: . ?
Как безопаснее и рациональнее поступать? Как в больших проектах поступают на этот счет?

Зачем часто писать std. если можно один раз using namespace std?
зачем часто писать std:: если можно один раз using namespace std?

Пространство имен — namespace std или std::
В каких случая лучше писать (std::cout) или просто прописать (namespace std) и почему ?

Есть большое множивство разнообразного функционала и оно скрыто в std
Проше будит обьяснить так если ты создаш 2-ве функции с одинаковыми именами ты не сможиш их применять однако если ты разместиш их прототипы в разных хедерах и подключиш только 1-н то все будит нормально ) тоесть std это стандартная пространство имен но если ты попробуеш создать чтото такое что уже там присутствует или имеет эдентичное название ты получиш ошибку . а когда ты пишиш using namespace std ты достаеш все что там храниться и можиш использовать в своей проге

Добавлено через 5 минут
Однако такжи можно не использовать все пространство имен а доставать только то что тебе необходимо например
std::cout
std::cin

в таком случае ты сможиш использовать все что тебе необходимо из std и такжи использовать свои классы функции имеющие эдентичные названия с теми что хранятся в std

Есть большое множивство разнообразного функционала и оно скрыто в std
Проше будит обьяснить так если ты создаш 2-ве функции с одинаковыми именами ты не сможиш их применять однако если ты разместиш их прототипы в разных хедерах и подключиш только 1-н то все будит нормально ) тоесть std это стандартная пространство имен но если ты попробуеш создать чтото такое что уже там присутствует или имеет эдентичное название ты получиш ошибку . а когда ты пишиш using namespace std ты достаеш все что там храниться и можиш использовать в своей проге

Добавлено через 5 минут
Однако такжи можно не использовать все пространство имен а доставать только то что тебе необходимо например
std::cout
std::cin

в таком случае ты сможиш использовать все что тебе необходимо из std и такжи использовать свои классы функции имеющие эдентичные названия с теми что хранятся в std

точно не скажу но printf это функция Си возможно что она заложина в глубине самого языка и не относиться к std )
ух щяз меня бить будут ))

Добавлено через 6 минут
Но уверености 0 ибо с принтф ваапше не общяюсь)

alex1392, пожалуйста, пишите грамотно, в редакторе сообщений есть же подчеркивание неправильных слов. Читать невозможно ИМХО

вообще верно, сишные функции относятся к глобальному пространству имен, но если добавлять хидеры например #include , то все функции этого файла помещаются в std

пример — пишешь ты игру — и есть у тебя в игре собачка, кошечка и человек, и вот пишешь ты графику и обзываешь классы HymanGraphic, CatGraphic и DogGraphic. Для звуков извлекаемых из твоих персонажей — HumanSound, CatSound, DogSound — в таком духе то есть для каждого модуля придумывать уникальное имя чтоб конфликтов не было. С пространствами имен ты определяешь пространства Graphic и Sound и сразу видно что к чему относится — ну няша же

Решение

Представьте себе Вашу файловую систему без каталогов — всё в корневике (в глобальном пространстве имен).
Какие проблемы могут возникнуть?
Самое первое — нельзя иметь два файла с одним именем на самом деле можно, но сейчас не об этом потому как возникнет конфликт имен.
Теперь допустим, что всё же у нас два разных файла с одним именем (файл1) оказались в корневике и Вам начальник со свирепым выражением лица, крича и разбрызгивая во все стороны свою слюну кричит «Открой файл1», но вот беда — их два и какой открывать? У Вас по сути один нормальный путь — спросить какой именно, собственно компилятор так и делает — выдает ошибку с текстом на подобии «Имя ‘такое-то’ двусмысленно».
А если бы всё лежало по папкам, то коллизий бы не возникло.
Вам бы сказали открыть файл «файл1» из каталога «каталог1» ( каталог1::файл1 )
или открыть файл «файл1» из каталога «каталог2» ( каталог2::файл1 )

А теперь к примеру на программе:
А теперь представьте, что написали Вы программу, всё работает — класс, всё довольны!
И вот решили вдруг, что нужно еще сделать пару фишек. Нашли стороннюю библиотеку, которая отлично подходит для реализации этих самых «фишек», но вот беда в ней есть классы с таким же именем как и у Вас. Что делать? Создавать копию Вашего класса, но с другим именем? Ну это жестко.
Вот пространства имен призваны решать такие проблемы. Например, вся стандартная библиотека, содержится в одном пространстве имен std, а подключаемые файлы так же определяют свои пространства имен, например библиотека boost находится в пространстве имен boost. Если писать boost::vector, то будет понятно, что используется вектор из библиотеки boost, а не std.
Что касается using namespace такое-то, это означает примерно следующее:
«Использовать пространство имен такое-то в этой области видимости».
То есть мы «скидываем» всё содержимое пространства имен в «текущую» область видимости, тем самым её засоряя ( пример про корневой каталог без разделения на папки ).

То есть пространства имен можно рассматривать как уточнение имени сущности.

Источник