Using namespace std что значит
Namespaces (C++)
The following example shows a namespace declaration and three ways that code outside the namespace can accesses their members.
Use the fully qualified name:
Use a using declaration to bring one identifier into scope:
Use a using directive to bring everything in the namespace into scope:
using directives
The using directive allows all the names in a namespace to be used without the namespace-name as an explicit qualifier. Use a using directive in an implementation file (i.e. *.cpp) if you are using several different identifiers in a namespace; if you are just using one or two identifiers, then consider a using declaration to only bring those identifiers into scope and not all the identifiers in the namespace. If a local variable has the same name as a namespace variable, the namespace variable is hidden. It is an error to have a namespace variable with the same name as a global variable.
In general, avoid putting using directives in header files (*.h) because any file that includes that header will bring everything in the namespace into scope, which can cause name hiding and name collision problems that are very difficult to debug. Always use fully qualified names in a header file. If those names get too long, you can use a namespace alias to shorten them. (See below.)
Declaring namespaces and namespace members
Typically, you declare a namespace in a header file. If your function implementations are in a separate file, then qualify the function names, as in this example.
Function implementations in contosodata.cpp should use the fully qualified name, even if you place a using directive at the top of the file:
A namespace can be declared in multiple blocks in a single file, and in multiple files. The compiler joins the parts together during preprocessing and the resulting namespace contains all the members declared in all the parts. An example of this is the std namespace which is declared in each of the header files in the standard library.
Members of a named namespace can be defined outside the namespace in which they are declared by explicit qualification of the name being defined. However, the definition must appear after the point of declaration in a namespace that encloses the declaration’s namespace. For example:
This error can occur when namespace members are declared across multiple header files, and you have not included those headers in the correct order.
The global namespace
The std namespace
Nested namespaces
Namespaces may be nested. An ordinary nested namespace has unqualified access to its parent’s members, but the parent members do not have unqualified access to the nested namespace (unless it is declared as inline), as shown in the following example:
Ordinary nested namespaces can be used to encapsulate internal implementation details that are not part of the public interface of the parent namespace.
Inline namespaces (C++ 11)
In contrast to an ordinary nested namespace, members of an inline namespace are treated as members of the parent namespace. This characteristic enables argument dependent lookup on overloaded functions to work on functions that have overloads in a parent and a nested inline namespace. It also enables you to declare a specialization in a parent namespace for a template that is declared in the inline namespace. The following example shows how external code binds to the inline namespace by default:
The following example shows how you can declare a specialization in a parent of a template that is declared in an inline namespace:
You can use inline namespaces as a versioning mechanism to manage changes to the public interface of a library. For example, you can create a single parent namespace, and encapsulate each version of the interface in its own namespace nested inside the parent. The namespace that holds the most recent or preferred version is qualified as inline, and is therefore exposed as if it were a direct member of the parent namespace. Client code that invokes the Parent::Class will automatically bind to the new code. Clients that prefer to use the older version can still access it by using the fully qualified path to the nested namespace that has that code.
The inline keyword must be applied to the first declaration of the namespace in a compilation unit.
Namespace aliases
Namespace names need to be unique, which means that often they should not be too short. If the length of a name makes code difficult to read, or is tedious to type in a header file where using directives can’t be used, then you can make a namespace alias which serves as an abbreviation for the actual name. For example:
anonymous or unnamed namespaces
You can create an explicit namespace but not give it a name:
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 в отношении пространства имен std.
Некоторые говорят использовать ‘ using namespace std ‘, другие говорят, что нет, а вместо этого используют префикс std-функций, которые должны использоваться с ‘ std:: ‘, в то время как другие говорят, что используйте что-то вроде этого:
для всех std-функций, которые будут использоваться.
Каковы плюсы и минусы каждого из них?
Ошибка обычно длинная и недружелюбная, потому что std::count это шаблон с некоторыми длинными вложенными типами.
Это нормально, потому что std::count входит в глобальное пространство имен, а счетчик функций скрывает его.
Исключение основ (необходимость добавления std :: infront всех объектов / функций stl и меньшая вероятность конфликта, если у вас нет ‘using namespace std’)
Также стоит отметить, что никогда не следует ставить
В файле заголовка, поскольку он может распространяться на все файлы, которые включают этот файл заголовка, даже если они не хотят использовать это пространство имен.
В некоторых случаях очень полезно использовать такие вещи, как
Сначала немного терминологии:
Точно так же, если вы можете обойтись несколькими объявлениями using (вместо директив using ) для определенных типов в std пространстве имен, тогда нет причин, по которым вы не должны иметь только эти конкретные имена, перенесенные в текущее пространство имен. К тому же, я думаю, что было бы безумием и хлопотно иметь дело с 25 или 30 объявлениями using, когда одна директива using также подойдет.
Также хорошо иметь в виду, что бывают случаи, когда вы должны использовать объявление using. Обратитесь к статье 25 Скотта Мейерса: подумайте о поддержке безбрасывающего свопа из Эффективного C ++, Третье издание. Чтобы универсальная шаблонная функция использовала «лучший» метод подкачки для параметризованного типа, вам необходимо использовать объявление с использованием объявления и поиск, зависящий от аргументов (также известный как ADL или поиск по Кенигу):
Херб Саттер и Андрей Александреску говорят об этом в «Правиле 59: Не записывайте использование пространств имен в заголовочный файл или перед #include» своей книги «Стандарты кодирования C ++: 101 правила, рекомендации и лучшие практики»:
Вкратце: вы можете и должны использовать пространство имен, используя объявления и директивы в ваших файлах реализации после #include директив, и вам это нравится. Несмотря на неоднократные утверждения об обратном, декларации и директивы, использующие пространства имен, не являются злом и не противоречат цели пространств имен. Скорее, они делают пространства имен пригодными для использования.
Струпструп часто цитируется как сказал: «Не загрязняйте глобальное пространство имен» в «Языке программирования C ++, третье издание». Он действительно так говорит (C.14 [15]), но ссылается на главу C.10.1, где говорит:
Объявление using добавляет имя в локальную область видимости. С помощью директивы не делает; он просто делает имена доступными в той области, в которой они были объявлены. Например:
Локально объявленное имя (объявленное обычным объявлением или использованием-объявлением) скрывает нелокальные объявления с тем же именем, а любые незаконные перегрузки имени обнаруживаются в точке объявления.
Когда библиотеки, объявляющие много имен, становятся доступными с помощью директив using, существенным преимуществом является то, что конфликты неиспользуемых имен не считаются ошибками.
Я надеюсь увидеть радикальное сокращение использования глобальных имен в новых программах, использующих пространства имен, по сравнению с традиционными программами на C и C ++. Правила для пространств имен были специально созданы, чтобы не давать преимуществ «ленивому» пользователю глобальных имен перед тем, кто заботится о том, чтобы не загрязнять глобальную область видимости.
И как получить такое же преимущество, как «ленивый пользователь глобальных имен»? Используя преимущество директивы using, которая безопасно делает имена в пространстве имен доступными для текущей области.
Using namespace std что значит
using namespace std;
Несмотря на свой небольшой размер, этот пример демонстрирует типичную структуру программы на C++. Рассмотрим эту структуру в деталях. Функции представляют собой основу, на которой строится любая программа C++. Данная программа состоит из единственной функции с названием main ().
Функция main(). Когда программа на языке C++ запускается на выполнение, первым исполняемым оператором становится первый оператор функции main(). Программа может состоять из множества функций, классов и прочих элементов, но при ее запуске управление всегда передается функции main(). Если в программе не содержится функции с именем main(), то при попытке запустить такую программу будет выведено сообщение об ошибке. В программах на C++ реальные действия, выполняемые этими программами, сводятся к вызову функцией main() методов различных объектов. Кроме того, функция main() может вызывать другие, независимые функции.
Операторы. Оператор является структурной единицей программы на C++. В примере содержатся 2 оператора:
3 Директивы препроцессора и комментарии
Директива using . Каждую программу на C++ можно разбить на несколько так называемых пространств имен.
Комментарии являются важной частью любой программы. Они помогают разобраться в действиях программы как разработчику, так и любому другому, читающему код. Компилятор игнорирует все, что помечено в программе как комментарий, поэтому комментарии не включаются в содержимое исполняемого файла и никак не влияют на ход исполнения программы.
Дополним пример комментариями.
# include iostream > //директива препроцессора
using namespace std; // директива using
int main() // функция с именем main
cout язык\n «; //оператор
> //конец тела функции
Комментарии начинаются с двойной косой черты // и заканчиваются концом строки. Комментарий может начинаться как в начале строки, так и после какого-либо оператора.
4 Стандартные типы данных в C++
Переменные являются фундаментальной частью любого языка. Каждая переменная имеет имя и может принимать различные значения. Переменные хранятся в определенных участках памяти. Когда переменной присваивается значение, оно записывается в ячейку памяти, связанную с данной переменной. Большинство языков программирования поддерживают определенный набор типов переменных, в который входят целые, вещественные и символьные типы.
Нужно четко знать разницу между терминами определение переменной и объявление переменной. Объявление переменной предполагает указание имени переменной (например, var1) и ее типа ( int и т. д.). Если при объявлении переменной одновременно выделяется память под нее, то происходит определение переменной. Операторы int var1; int var2; являются и объявлениями, и определениями, поскольку выделяется память под переменные var1 и var2. В программах чаще употребляют определения.
При составлении идентификатора используются буквы и нижнего и верхнего регистров, цифры от 0 до 9, и символ подчеркивания _.
Целочисленная переменная. Целые типы соответствуют целым числам, тип данных нужен для того, чтобы оперировать с дискретным числом объектов.
Существует несколько целых типов данных, имеющих различную длину.
В 32-разрядных ОС размер переменной int равен 4 байтам (32 битам), что позволяет хранить в переменной типа int значения от -2 147 483 648 до 2 147 483 647.
Фрагмент программы, использующей переменные типа int :
int var1; //описание переменной var1
int var2; //описание переменной var2
var1 =20; //присвоение значения переменной var1
var2 = var1 +10; //присвоение значения переменной var2
cout endl ; //вывод значения переменной var2
Операторы int var1; int var2; определяют две целые переменные var1 и var2. Ключевое слово int определяет тип переменной. Подобные операторы, называемые объявлениями, должны разделяться точкой с запятой (;), как и любые другие операторы программы. Перед тем как воспользоваться переменной, обязательно нужно объявить ее. Объявления переменных могут располагаться в любом месте программы. Не обязательно делать все объявления переменных до появления первого исполняемого оператора. Тем не менее, объявления наиболее часто употребляемых переменных целесообразно производить в начале программы, чтобы обеспечить ее удобочитаемость. Операция присваивания. Операторы
— присваивают значения переменным var1 и var2.
— знак = означает присваивание значения, стоящего в правой его части, переменной, стоящей в левой части.
— переменной var1, до этого не имевшей значения, присваивается значение 20.
— константы сохраняют свое значение на протяжении всего выполнения программы.
— значение целой константы должно содержаться в интервале, соответствующем диапазону представления целых чисел.
— оператор cout cout endl ; отображает значение переменной var2.
— операция cout знают, каким образом отличать целое число от строки и как обрабатывать каждое из них.
— если выводится на экран целое число, то оно отображается в числовом формате, а при выводе строки она отображается в виде текста.
— это кажется очевидным, но за этими действиями стоит механизм перегрузки операций, типичный для C++.
if ( another_age >= 0)
cout another _ year
cout another_year родились!\n «; >
Программа запрашивает у пользователя текущий год, возраст пользователя и еще один год, затем вычисляет возраст пользователя, который будет у него во втором введенном году.
После компиляции программы ее можно запустить на выполнение. Результат выполнения на экране будет выглядеть примерно так:
• Введите свой возраст (в годах).
• Введите год, для которого вы хотите узнать свой возраст.
• В 2017 году вам будет 29
Иногда символьные переменные используют для представления целых чисел, заключенных в указанном диапазоне, но гораздо чаще в таких переменных хранятся ASCII-коды символов.
Таблица ASCII-кодов предназначена для интерпретации символов как чисел. Эти числа заключены в диапазоне от 0 до 127.
Операционные системы Windows расширяют верхнюю границу этого диапазона до 255 для того, чтобы включить в ASCII-таблицу символы национальных алфавитов и псевдографические символы.
Переменные типа » char » существенно отличаются от » int » при выполнении ввода данных с клавиатуры и вывода на экран.
Программа для печати фрагмента таблицы ASCII (от 32-го символа (пробел) до 126-го (символ ‘
Пространства имен (namespaces) в C++
Пространство имен в C ++ — это обобщенная область видимости. Его объявление начинается с зарезервированного слова namespace, за которым следует имя по выбору программиста, а затем блок в фигурных скобках. Блок содержит базовые объявления и / или определения объектов, функций и других сущностей C ++.
Рассмотрим следующие два скалярных оператора в глобальной области в следующей программе:
int varId = 5 ;
float varId = 2.3 ;
Попытка скомпилировать эту программу приводит к ошибке компиляции. Есть две переменные с одинаковым именем varId. Хотя это две разные переменные двух разных типов, int и float, компилятор отклоняет два объявления, потому что они имеют одно и то же имя. Следующая программа решает эту проблему, объявляя переменные с одинаковыми именами в двух разных обобщенных областях:
namespace NA
<
int varId = 5 ;
>
namespace NB
<
float varId = 2.3 ;
>
int main ( )
<
cout NA :: varId ‘ \n ‘ ;
cout NB :: varId ‘ \n ‘ ;
Результат выглядит следующим образом:
В этой статье рассматривается основная концепция пространства имен и его использование в языке программирования C ++. Чтобы следовать этой статье, вы должны иметь базовые знания языка C ++. Вы также должны знать область действия C ++, хотя она кратко объясняется в этой статье. Чтобы узнать больше о области действия C ++, найдите фразу «Область действия в C ++» (без кавычек) в поле поиска любой веб-страницы linuxhint.com и нажмите Enter. Это приведет вас к статье, написанной этим автором.
Что такое пространство имен?
Декларативная область — это самая большая часть программы, в которой допустимо имя объекта (переменной). Эта область называется областью действия. Пространство имен в C ++ — это обобщенная область видимости, основной целью которой является разрешение конфликтов имен. Пространство имен имеет базовые объявления и / или определения сущностей.
Глобальное пространство имен и его проблема
Глобальное пространство имен — это глобальная область видимости. Рассмотрим следующую короткую программу:
int ident = 55 ;
float ident = 12.17 ;
В приведенной выше программе есть две переменные, обе называемые идентификатором. Эти переменные находятся в глобальной области видимости; то есть они находятся в глобальном пространстве имен. Попытка скомпилировать эту программу завершится ошибкой. Глобальная область видимости не принимает более одной переменной с одинаковым именем, поэтому существует необходимость в настраиваемом пространстве имен.
Пользовательское пространство имен
namespace NA
<
int varInt = 6 ;
float flt ;
>
namespace NB
<
int varInt = 7 ;
float flt ;
>
int main ( )
<
cout NA :: varInt ‘ \n ‘ ;
cout NB :: varInt ‘ \n ‘ ;
NA :: flt = 2.5 ;
NB :: flt = 4.8 ;
cout NA :: flt ‘ \n ‘ ;
cout NB :: flt ‘ \n ‘ ;
Обратите внимание, что имена NA :: flt и NB :: flt в конечном итоге определены в функции main (). C ++ не допускает такого определения в глобальной области видимости.
Обратите внимание, что настраиваемое пространство имен является вложенным пространством имен для глобального пространства имен.
Директива использования
Чтобы не вводить все время «namepace :: name» вместо просто «name» после объявления пространства имен, вы можете использовать директиву using. Синтаксис использования директивы using следующий:
С помощью директивы не директива препроцессора, поэтому она заканчивается точкой с запятой (;).
Следующая программа иллюстрирует использование директивы using и др.:
namespace NB
<
int varInt = 7 ;
int func ( )
<
return varInt ;
>
>
int fn ( )
<
using namespace NB ;
int myVar2 = func ( ) ;
//other objects and functions from NB follow.
return myVar2 ;
>
int myVar3 = NB :: func ( ) ;
int main ( )
<
cout fn ( ) ‘ ‘ myVar3 ‘ \n ‘ ;
Переменная, объявленная в глобальной области (глобальном пространстве имен), просматривается от точки объявления до конца файла. Это также видно во вложенных пространствах имен (вложенных областях), таких как вложенная область видимости функции fn () выше. С помощью директивы соединяет его пространство имен из позиции, в которой он размещен в конце области, в которой он размещен.
Имя func () из пространства имен NB нельзя увидеть под определением fn (), потому что » using namespace NB;» был помещен в область действия функции (блок). При этом условии, чтобы использовать функцию » func () » вне блока (области) пространства имен NB, ему должен предшествовать » NB :: «, как в следующем операторе:
С помощью директивы присоединяется своим пространством имен с внешним гнездовым пространством именами из положения, в котором он находится на конец внешних вложенности имен. В следующей программе пространство имен NA объединено с глобальным пространством имен. Оба пространства имен затем расширяются в пространство имен определения функции fn (), в котором они объединяются с пространством имен NB. Пространство имен NB заканчивается в конце определения функции fn (), а два предыдущих пространства имен продолжаются до конца файла (считывания кода).
namespace NA
<
int varInt = 6 ;
int func ( )
<
return varInt ;
>
namespace NB
<
int varInt = 7 ;
int func ( )
<
return varInt ;
>
>
using namespace NA ;
int myVar0 = varInt ;
//other objects and functions from :: and NB follow.
int fn ( )
<
int myVar1 = varInt ;
using namespace NB ;
int myVar2 = NB :: func ( ) ;
//other objects and functions from NB follow, till end of this scope.
return myVar1 + myVar2 ;
>
//Only objects and functions from :: and NB follow.
int myVar3 = NB :: func ( ) ;
int main ( )
<
cout myVar0 ‘ ‘ fn ( ) ‘ ‘ myVar3 ‘ \n ‘ ;
На выходе будет 6, 13, 7.
Под утверждением » using namespace NA; «Переменные из глобального пространства имен и пространства имен NA могут использоваться без указания их исходного пространства имен. Следующий оператор использует varInt пространства имен NA. Область объединенного пространства имен global и NA простирается в пространство имен функции fn (). Итак, varInt первого оператора в области видимости функции fn () относится к пространству имен NA.
Поскольку область для глобального пространства имен и пространства имен NA распространяется на всю область видимости fn (), после » int myVar2 = NB :: func ();, «Любое имя из пространства имен NB может использоваться только в области fn () без предшествующего ему» NB :: «, только если оно не встречается в NA и глобальных пространствах имен (блоках). В противном случае ему должно предшествовать » NB :: «. Область объединенных пространств имен для NA и global продолжается ниже определения fn () и в функцию main () до конца файла.
Расширение пространства имен NB начинается с » int myVar2 = NB :: func (); «В блоке fn () и заканчивается в конце блока определения fn ().
Примечание: Пространства имен, регионы которых соединяются, не должны иметь одинаковые имена переменных в разных блоках пространств имен, так как это все равно вызовет конфликт.
Области пространства имен
Пространство имен — это область видимости. Помимо глобального пространства имен (глобальная область видимости), любое пространство имен должно быть объявлено в блоке. Этот блок является первой частью возможных распределенных областей пространства имен. С помощью директивы using пространство имен может быть расширено как регионы в других областях.
Объекты, объявленные в теле пространства имен, называются членами этого пространства имен, а имена, введенные этими объявлениями в декларативную область пространства имен, называются именами членов этого пространства имен.
Вложенные пространства имен
Следующая программа показывает вложенные пространства имен:
namespace A
<
int i = 1 ;
namespace B
<
int i = 2 ;
namespace C
<
int i = 3 ;
>
>
>
int main ( )
<
cout A :: i ‘ ‘ A :: B :: i ‘ ‘ A :: B :: C :: i ‘ \n ‘ ;
Обратите внимание, что доступ к трем значениям был осуществлен с помощью оператора разрешения области видимости.
Стандартное пространство имен
В C ++ есть библиотека, называемая стандартной библиотекой. Имена объектов, функций и других сущностей в этой библиотеке взяты из пространства имен, называемого стандартным пространством имен, записанного как std. Стандартная библиотека содержит подбиблиотеки, и одна из этих подбиблиотек — iostream. Библиотека iostream содержит объект cout, который используется для отправки результатов на консоль (терминал).
Имя cout должно находиться в пространстве имен std. Чтобы использовать iostream с его пространством имен std, программа должна быть следующей:
Обратите внимание на использование директивы using и std. Термин » #include » является директивой препроцессора и не заканчивается точкой с запятой. Он включает в себя «файл» iostream в позиции своей директивы.
Заключение
Пространство имен — это область видимости. Описание (определение) пространства имен содержит базовые объявления и / или определения объектов, функций и других сущностей C ++. Вне определения пространства имен доступ к имени можно получить с помощью синтаксиса » namespaceName :: name «. Помимо глобального пространства имен (глобальная область видимости), любое пространство имен должно быть объявлено в блоке. Этот блок является первой частью возможных распределенных областей пространства имен. С помощью директивы using пространство имен может быть расширено как регионы в других областях. Пространства имен, регионы которых соединяются, не должны иметь одинаковые имена переменных в разных блоках пространств имен, так как это все равно вызовет конфликт имен.