Using namespace std что это такое и как используется в Visual C++

Using namespace std что это такое и как используется в Visual C++

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

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

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

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

Содержание:

На изображении представлено несколько вариаций доступа к кодировкам, располагающихся в пределах и за его ограждениями:

Директива Using

Using директива разрешает эксплуатацию всех имеющихся имен, которые включены в пространство имени.

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

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

Тогда можно добавить только необходимые идентификаторы, а остальные не трогать.

Важно отметить, что если наименование локальной переменной с основной будут совпадать, то в таком случае первая будет находится в скрытом доступе.

Стоит принять во внимание, что создание переменных с одинаковым наименованием является недопустимым действием.

Совет! Для удобства использования, using директива может быть расположена в верхушке файла формата cpp., либо наоборот, помещается внутрь созданной библиотеки.

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

Если нет крайней необходимости, то директиву using не стоит размещать в заголовках файлом формата H.

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

Для файлов оптимальным решением станет использование полного наименования.

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

Читайте также:

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

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

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

Чтобы реализовать функцию contosodata формата cpp., также важно использовать полное наименование и в том случае, когда директива стоит в самом начале:

Using namespace std. может содержать объявления сразу в нескольких разделах, находящихся в одном и том же файле.

За счет компилятора происходит объединение всех элементов, пока происходит обработка данных.

Далее пространство будет включать все доступные имена и члены, которые были заявлены во всех разделах.

Так, например, std., как правило, объявляется во всех заголовках доступных файлов, располагающихся в доступных библиотеках стандартного типа.

Что касается определения, то оно должно быть после объявления в пространстве имени, где оно создано.

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

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

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

Совет! Если нет острой необходимости, то рекомендуется избегать включения членов в пространство глобального типа.

Существенным исключением из правил может быть только главная (main) опция, подразумевающая обязательное включение в обширном пространстве.

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

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

Std:: или using namespace std;

Вопрос к профессионалам.
Меня давно интересуют такие вопросы:
1) Почему, многим, вроде бы не безграмотным С++-шникам, в консольных приложениях вместо одной строки :
using namespace std;
нравится везде перед cout, cin, endl, string и т.п. дописывать std:: ?
Это стиль такой пространно-корявый, или есть какое-то логическое объяснение?

2) Почему даже в несложных программах многие спецы предпочитают вместо коротких имён давать переменным пространные имена?

3) Почему многие спецы для несложных программ вместо необходимых заголовочных файлов используют библиотеки «на все случаи жизни»?

Утрируя, можно сказать, что простая программа сложения двух чисел:

08.10.2017, 18:43

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

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

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

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

Не воспринимает ни std::cout, ни std::cin. Вобщем ничего из std. Также не понимает iostream
Здравствуйте! Я хотел начать изучать язык C++. Набрал литературы. Установил Microsoft Visual C++.

08.10.2017, 18:50 2

Решение

что в коде программы пользовательский vector не переопределится на std::vector . Если тебе сильно не хочется по всему коду писать std::cin, можешь воспользоваться

08.10.2017, 18:51 3 08.10.2017, 18:53 4

1) Посмотрите внизу похожие темы. Это обсуждалось уже не раз.
2) Имена должны быть понятными. Хотя в программе из 10 строк тяжело запутаться, все равно лучше называть переменные нормально.
3) Так спецы точно не делают

08.10.2017, 18:53
08.10.2017, 18:54 5
08.10.2017, 18:56 6
08.10.2017, 18:56 7

1) неймспейсы для того и нужны чтоб раскидать имена в пространства имён. Если вам захочется определить свой класс который тоже называется cout то можете это сделать реализовав его в другом пространстве имен, иначе будет конфликт имен.

2) привычка и/или перфекционизм, наверное.

3) не понял вопрос. где какая библиотека нужна ту и надо использовать а не включать лишнее

08.10.2017, 19:28 8
08.10.2017, 19:47 9
08.10.2017, 23:06 10
08.10.2017, 23:22 11
09.10.2017, 16:45 [ТС] 12
09.10.2017, 17:16 13

Добавлено через 8 минут
Общее соображение такого, что любой мастер в любом деле со временем нарабатывает определённый стиль. Этот стиль вбирает в себя весь опыт мастера, все его ошибки и неудачи. Его стиль будет эффективным, но не всегда оптимальным. Зато его решения будут, как правило, работать почти всегда. И стиль его именно такой потому что он со временем набрал в свой багаж то, что работает хорошо и работает почти всегда.

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

Если мастер не делает чего-то очевидного, скорее всего это означает, что там есть подводные камни, на которые мастер уже наступал. Возможно ни один раз.

Добавлено через 4 минуты
Отвечая на вопрос, почему то или иное не используется что-либо в учебных целях, следует помнить, что мастер никогда не станет учить абстракции. Он будет учить тому, как он делает сам. Он сам может быть давно забыл, почему он не пишет using namespace std . Но, обучая новичков. Он тоже не станет этого делать. Просто потому, что не станет над этим задумываться.

SBP-Program

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

Что такое пространство имен в C++?

Пространство имен (namespace) – это способ объединения логически связанных объявлений под общим именем.

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

Получаем:

В примере созданы два пространства имен: first и second. Оба пространства содержат одинаковые переменные. Но именно факт принадлежности, например, переменной a к пространству first не позволяет её спутать с переменной из другого пространства имён. Это позволяет избегать конфликта имен.

означает, что используется переменная int а, объявленная в пространстве имен first. Это пример using-объявления. Оператор :: называется оператором определения области видимости.

Создаются пространства имен при помощи ключевого слова namespace:

Для того, чтобы использовать все имена из пространства имен можно применить директиву using namespace. Пример использования using namespace std:

using namespace std позволяет использовать имена из пространства имен std. std — это имя стандартной библиотеки C++.

Если в последнем примере убрать строку подключения пространства имен using namespace std, то надо будет указывать наименование пространства имен явно:

Пространство имен определяет область видимости. В примерах явно определялись пространства имён. А вот другие примеры пространств имен. Область видимости внутри функции — это тоже пространство имен. Область видимости глобальных переменных — это тоже пространство имен. Класс — это тоже пространство имен.

Возможно создание пространства имен без имени. Пример:

Здесь подразумевается использование директивы using namespace. Такие пространства имен нужны для ухода от возможного конфликта имен.

Если название пространства имен слишком длинное, то можно создать псевдоним пространства имен. Пример:

вводит псевдоним ug для пространства имен underground. Далее мы работаем с псевдонимом.

Если предполагается использовать только часть имён из пространства имен, то можно отобрать эту часть в новое пространство имен и использовать его. Пример:

Здесь из пяти переменных пространства имен underground мы предполагаем использовать только две. Создаём новое пространство имен ug, в котором имеются два using-объявления. Далее мы работаем с пространством имен ug.

Пространство имен можно изменить, т.е. дописать в него новые объявления. Пример:

Получаем:

Пространства имен можно вкладывать друг в друга Пример:

Получаем:

В примере namespace upper содержит namespace inner. Обратите внимание, как идёт обращение к полю внутреннего пространства имен:

Рассмотрим глобальное пространство имен. Здесь используют оператор :: без указания имени пространства. В глобальное пространство имен попадают глобальные объявления, включая соответствующие using-директивы. Пример глобального пространства имен:

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

using-директива делает доступными все имена из данного пространства имен, но не объявляет их локально.

using-объявление имеет приоритет перед using-директивой.

Получаем:

это using-директива, которая делает доступными все имена из пространства имен sbp.

это работа с локальной переменной а. Чтоб присвоить значения переменной а из пространства sbp, надо явно указать на sbp:

Это же относится и к глобальной переменной а.

Локальная переменная а закрывает глобальные переменные с тем же именем.

Теперь пример для using-объявления:

Получаем:

это using-объявление. Здесь локально объявляется переменная b из пространства имён sbp. После этого объявления можно проводить действия:

но using-объявление для а

привело бы нас к ошибке, ведь в примере уже определена локальная переменная а.

Урок №24. Конфликт имён и std namespace

Обновл. 11 Мар 2019 |

Допустим, вам нужно съездить к дальним родственникам в другой город. У вас есть только их адрес: г. Ржев, ул. Вербовая, 13. Попав в город Ржев, вы открываете Google Карты/Яндекс.Карты и видите, что есть две улицы с названием «Вербовая», ещё и в противоположных концах города! Какая из них нужна вам? Если у вас нет никакой дополнительной информации (например, вы знаете, что их дом находится возле аптеки или школы), вам придётся позвонить им и спросить. Чтобы подобной путаницы не возникало, все названия улиц в городе должны быть уникальными.

Аналогично и в C++, все идентификаторы (имена переменных/функций/классов и т.д.) должны быть уникальными. Если в вашей программе находятся два одинаковых идентификатора, то будьте уверены, ваша программа не скомпилируется: вы получите ошибку конфликта имён.

Пример конфликта имён

По отдельности файлы a.cpp, b.cpp и main.cpp скомпилируются. Однако, если a.cpp и b.cpp разместить в одном проекте — произойдёт конфликт имён, так как определение функции doSomething() находится сразу в обоих файлах.

Большинство конфликтов имён происходят в двух случаях:

Файлы, добавленные в один проект, имеют функцию (или глобальную переменную) с одинаковыми именами (ошибка на этапе линкинга).

Файл .cpp подключает заголовочный файл, в котором идентификатор конфликтует с идентификатором из файла .cpp (ошибка на этапе компиляции).

Как только программы становятся больше — используется больше идентификаторов. Следовательно, вероятность возникновения конфликта имён значительно возрастает. Хорошая новость заключается в том, что C++ предоставляет достаточно механизмов для предотвращения возникновения конфликтов имён (например: локальная область видимости или пространства имён).

std namespace

В первых версиях C++ все идентификаторы из стандартной библиотеки C++ (такие как cin/cout и т.д.) можно было использовать напрямую. Тем не менее, это означало, что любой идентификатор из стандартной библиотеки С++ потенциально мог конфликтовать с именем, которое вы выбрали для ваших собственных идентификаторов. Код, который работал, мог внезапно получить конфликт имён при подключении нового заголовочного файла из стандартной библиотеки С++. Или, что ещё хуже, код, написанный по стандартам одной версии С++, мог уже не работать в новой версии С++. Чтобы решить эту проблему, весь функционал стандартной библиотеки С++ перенесли в специальную область — пространство имён (англ. «namespace»).

Так как город гарантирует, что все улицы в его пределах имеют уникальные имена, так и пространство имён гарантирует, что все его идентификаторы — уникальны.

Таким образом, std::cout состоит из двух частей: идентификатор cout и пространство имён std. Весь функционал стандартной библиотеки C++ определён внутри пространства имён std (сокращенно от англ. «standard»).

Мы ещё поговорим о пространствах имён в следующих уроках, а также расскажем, как создать свой собственный namespace. Сейчас, главное, что вам нужно запомнить — всякий раз, когда вы используете идентификаторы из стандартной библиотеки С++ (например, cout), вы должны сообщать компилятору, что этот идентификатор находится внутри пространства имён std.

Правило: При использовании идентификаторов из пространств имён — указывайте используемые пространства имён.

Оператор разрешения области видимости (::)

Самый простой способ сообщить компилятору, что определённый идентификатор находится в определённом пространстве имён — использовать оператор разрешения области видимости (::). Например:

Урок №24. Конфликт имён и std namespace

Обновл. 11 Мар 2019 |

Допустим, вам нужно съездить к дальним родственникам в другой город. У вас есть только их адрес: г. Ржев, ул. Вербовая, 13. Попав в город Ржев, вы открываете Google Карты/Яндекс.Карты и видите, что есть две улицы с названием «Вербовая», ещё и в противоположных концах города! Какая из них нужна вам? Если у вас нет никакой дополнительной информации (например, вы знаете, что их дом находится возле аптеки или школы), вам придётся позвонить им и спросить. Чтобы подобной путаницы не возникало, все названия улиц в городе должны быть уникальными.

Аналогично и в C++, все идентификаторы (имена переменных/функций/классов и т.д.) должны быть уникальными. Если в вашей программе находятся два одинаковых идентификатора, то будьте уверены, ваша программа не скомпилируется: вы получите ошибку конфликта имён.

Пример конфликта имён

По отдельности файлы a.cpp, b.cpp и main.cpp скомпилируются. Однако, если a.cpp и b.cpp разместить в одном проекте — произойдёт конфликт имён, так как определение функции doSomething() находится сразу в обоих файлах.

Большинство конфликтов имён происходят в двух случаях:

Файлы, добавленные в один проект, имеют функцию (или глобальную переменную) с одинаковыми именами (ошибка на этапе линкинга).

Файл .cpp подключает заголовочный файл, в котором идентификатор конфликтует с идентификатором из файла .cpp (ошибка на этапе компиляции).

Как только программы становятся больше — используется больше идентификаторов. Следовательно, вероятность возникновения конфликта имён значительно возрастает. Хорошая новость заключается в том, что C++ предоставляет достаточно механизмов для предотвращения возникновения конфликтов имён (например: локальная область видимости или пространства имён).

std namespace

В первых версиях C++ все идентификаторы из стандартной библиотеки C++ (такие как cin/cout и т.д.) можно было использовать напрямую. Тем не менее, это означало, что любой идентификатор из стандартной библиотеки С++ потенциально мог конфликтовать с именем, которое вы выбрали для ваших собственных идентификаторов. Код, который работал, мог внезапно получить конфликт имён при подключении нового заголовочного файла из стандартной библиотеки С++. Или, что ещё хуже, код, написанный по стандартам одной версии С++, мог уже не работать в новой версии С++. Чтобы решить эту проблему, весь функционал стандартной библиотеки С++ перенесли в специальную область — пространство имён (англ. «namespace»).

Так как город гарантирует, что все улицы в его пределах имеют уникальные имена, так и пространство имён гарантирует, что все его идентификаторы — уникальны.

Таким образом, std::cout состоит из двух частей: идентификатор cout и пространство имён std. Весь функционал стандартной библиотеки C++ определён внутри пространства имён std (сокращенно от англ. «standard»).

Мы ещё поговорим о пространствах имён в следующих уроках, а также расскажем, как создать свой собственный namespace. Сейчас, главное, что вам нужно запомнить — всякий раз, когда вы используете идентификаторы из стандартной библиотеки С++ (например, cout), вы должны сообщать компилятору, что этот идентификатор находится внутри пространства имён std.

Правило: При использовании идентификаторов из пространств имён — указывайте используемые пространства имён.

Оператор разрешения области видимости (::)

Самый простой способ сообщить компилятору, что определённый идентификатор находится в определённом пространстве имён — использовать оператор разрешения области видимости (::). Например:

Использование пространства имен std

2 Ryan [2011-05-21 00:02:00]

Я занимаюсь классом программирования в школе, и я хотел начать делать программирование на С++ вне класса. Моя школа с использованием Microsoft Visual С++ 6.0 (с 1998 года), поэтому она по-прежнему использует , а не и using namespace std . Когда я начал работать, я не мог понять, как и когда использовать using namespace std , и когда нужно просто использовать такие вещи, как std::cout (например), а также ограничения и другие применения для ключевого слова namespace. В частности, если я хочу создать программу с iostream и iomanip, должен ли я указывать «использование пространства имен std» дважды, или есть что-то другое, что мне нужно было бы использовать, или я могу просто сделать то же самое, что и Я сделал с iostream? Я пробовал погулять, но я ничего не понял. Заранее спасибо за помощь.

c++ namespaces visual-c++ std header

5 ответов

11 riwalk [2011-05-21 00:19:00]

Хорошо, несколько вещей есть, но это управляемо.

Прежде всего, разница между:

Это просто вопрос объема. Сфера — всего лишь причудливый способ сказать, как компилятор распознает имена переменных и функций, среди прочего. Пространство имен делает не что иное, как добавление дополнительного уровня области видимости для всех переменных в этом пространстве имен. Когда вы вводите using namespace std , вы берете все внутри пространства имен std и перемещаете его в глобальную область, чтобы вы могли использовать более короткий cout вместо более полного std::cout .

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

Там будут люди, которые говорят вам: «Не используйте using namespace std . «, но они редко говорят вам, почему. Допустим, что у меня есть следующая программа, где все, что я пытаюсь сделать, это определить два целых числа и распечатать их:

Когда я использую using namespace std , я открываю дверь для именования столкновений. Если я (случайным образом) назвал переменную той же самой, что и в заголовке, то ваша программа сломается, и вам будет сложно определить, почему.

Я могу написать ту же программу, что и раньше (но заставить ее работать), не используя инструкцию using namespace std :

Надеюсь, это прояснило некоторые вещи.

4 cHao [2011-05-21 00:09:00]

Если вы используете имена заголовков без .h , то объявленные/определенные в нем элементы будут находиться в пространстве имен std . Вам нужно использовать только using namespace std; один раз в области, где вы хотите импортировать вещи, чтобы получить все; более одного using namespace std; ничего не помогает.

Я бы рекомендовал против using namespace std; вообще. Вместо этого я предпочитаю говорить, например, using std::cout; , чтобы сохранить имена в std от конфликта с моим.

может вызвать таинственные проблемы, потому что left и right существуют в пространстве имен std (как IO-манипуляторы), и они импортируются, если вы лениво говорите using namespace std; . Если вы хотите использовать IO-манипуляторы вместо вывода переменных, вы можете быть немного разочарованы. Но намерение не является очевидным в любом случае. Возможно, вы просто забыли, что у вас есть ints с именем left и right .

Вместо этого, если вы скажете

все работает так, как ожидалось. Кроме того, вы можете посмотреть, что вы на самом деле используете (что в данном случае не содержит ничего из ), поэтому вам проще сводить ваши нужды к тому, что вам нужно.

1 Alan [2011-05-21 00:15:00]

Конкретно для using namespace std

Вы действительно никогда не должны использовать его в файле заголовка. Таким образом, вы импортировали весь «std» в глобальное пространство имен для всех, кто включает ваш файл заголовка, или для кого-либо еще, который включает файл, который включает ваш файл.

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

Здесь — хорошая ссылка, которая описывает пространства имен и как они работают.

Оба метода верны, то есть вы можете либо ввести пространство имен с помощью инструкции «using», либо вы можете квалифицировать всех членов пространства имен. Это вопрос стиля кодирования. Я предпочитаю квалификацию с пространствами имен, потому что это дает понять читателю, в котором пространство имен определяется функцией/классом.

Кроме того, вам не нужно вводить пространство имен дважды, если вы включаете несколько файлов. Достаточно одного оператора.

1 [2011-05-21 00:20:00]

В приведенных выше примерах все символы в пространстве имен A становятся видимыми в пространстве имен B , как будто они были объявлены там.

Этот импорт влияет только на данный блок перевода. Так, например, когда в вашем файле реализации (т.е. .cpp ) вы выполняете using namespace std; , вы в основном импортируете все символы из пространства имен std в глобальную область.

Вы также можете импортировать определенные символы, а не все, например:

Вы можете сделать это в глобальной области видимости пространства имен или в области функций, например:

Программист должен решить, когда использовать полностью квалифицированные имена и когда использовать ключевое слово using . Как правило, очень плохо вставить using в заголовочные файлы. Профессиональные программисты на C++ почти никогда не делают этого, если это не требуется для решения какой-либо проблемы, или они на 100% уверены, что это не испортит разрешение типа для тех, кто использует этот заголовок.

Однако в исходном файле (ни один из них не содержит исходных файлов), все в порядке делать какие-либо операторы использования, если нет конфликтующих имен в разных пространствах имен. Это только вопрос вкуса. Например, если во всем коде есть множество символов из разных пространств имен, я бы предпочел хотя бы некоторые подсказки относительно того, где они объявлены. Но все знакомы с STL, поэтому using namespace std; никогда не должен навредить.

Там также могут быть несколько длинных пространств имен, и в этих случаях удобно использовать псевдонимы пространства имен. Например, есть библиотека Boost.Filesystem, которая помещает все ее символы в пространство имен boost::filesystem . Использование этого пространства имен будет слишком большим, поэтому люди обычно делают что-то вроде этого:

Кроме того, почти нормально использовать псевдонимы пространства имен в заголовках, например:

.. и извлечь выгоду из меньшего набора текста. Случается, что пользователи, которые будут использовать этот заголовок, не будут импортировать всю библиотеку файловой системы, сказав using namespace MyLib; . Но тогда они будут импортировать пространство имен «fs» из вашей библиотеки, которое может конфликтовать с чем-то другим. Так что лучше не делать этого, но если вы хотите это слишком плохо, лучше сказать using namespace boost::filesystem там.

Итак, вернемся к вашему вопросу. Если вы пишете библиотеку с использованием потоков ввода-вывода С++, лучше не иметь никаких операторов using в заголовках, и я бы пошел с using namespace std; в каждом файле cpp . Например:

Поточный ввод-вывод в C++

В С++, как и в С, нет встроенных в язык средств ввода-вывода.

В С для этих целей используется библиотека stdio.h .
В С++ разработана новая библиотека ввода-вывода iostream , использующая концепцию объектно-ориентированного программирования:

Библиотека iostream определяет три стандартных потока:

  • cin стандартный входной поток ( stdin в С)
  • cout стандартный выходной поток ( stdout в С)
  • cerr стандартный поток вывода сообщений об ошибках ( stderr в С)

Для их использования в Microsoft Visual Studio необходимо прописать строку:

Для выполнения операций ввода-вывода переопределены две операции поразрядного сдвига:

  • >> получить из входного потока
  • cout

Возможно многократное назначение потоков:
cout

Ввод информации

При этом из входного потока читается последовательность символов до пробела, затем эта последовательность преобразуется к типу идентификатора, и получаемое значение помещается в идентификатор:

Возможно многократное назначение потоков:
cin >> переменная1 >> переменная2 >>. >> переменнаяn;

При наборе данных на клавиатуре значения для такого оператора должны быть разделены символами (пробел, n, t ).

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

Результат выполнения

Для ввода текста до символа перевода строки используется манипулятор потока getline() :

Результат выполнения

Манипуляторы потока

Функцию — манипулятор потока можно включать в операции помещения в поток и извлечения из потока ( >).

В С++ имеется ряд манипуляторов. Рассмотрим основные:

Манипулятор Описание
endl Помещение в выходной поток символа конца строки ‘n’
dec Установка основания 10-ой системы счисления
oct Установка основания 8-ой системы счисления
hex Установка основания 16-ой системы счисления
setbase Вывод базовой системы счисления
width(ширина) Устанавливает ширину поля вывода
fill(‘символ’) Заполняет пустые знакоместа значением символа
precision(точность) Устанавливает количество значащих цифр в числе (или после запятой) в зависимости от использования fixed
fixed Показывает, что установленная точность относится к количеству знаков после запятой
showpos Показывает знак + для положительных чисел
scientific Выводит число в экспоненциальной форме
get() Ожидает ввода символа
getline(указатель, количество) Ожидает ввода строки символов. Максимальное количество символов ограничено полем количество

Пример Программа ввода-вывода значения переменной в C++

Та же программа, написанная на языке Си

Пример Использование форматированного вывода

Результат выполнения

Еще один пример использования форматированного вывода: для t∈[0;3] с шагом 0,5 вычислить значение y=cos(t).

Результат выполнения

Ссылка на основную публикацию