Void greeting();/*это пространство имен содержит функцию с тем же
именем*/
}
Void big_greeting(); /*эта функция не попадает ни в одно из созданных подпространств,т.Е. Принадлежит пространству имен std */
int main()
{
{
using namespace NameSpase2;
/*в этом блоке используются имена, определенные в пространстве имен NameSpase2, std и в глобальном пространстве имен */
greeting();
}
{
using namespace NameSpase1;
/*в этом блоке используются имена, определенные в пространстве имен NameSpase1, std и в глобальном пространстве имен */
greeting();
}
/*начиная со следующей строки, используются только те определения которые заданы в пространстве имен std и глобальном пространстве имен */
big_greeting();
cout<<endl<<sum(10,15)<<endl;
char w;
cin>>w;
return 0;
}
//Определение функций
/*определение функции greeting() поместим в пространство имен NameSpase1 */
namespace NameSpase1
{//открывается блок пространста имен NameSpase1
void greeting()
{
cout<<"Privet1"<<endl; //функция содержит только один оператор
}
}//закрывается блок пространста имен NameSpase1
/*определение функции greeting() поместим в пространство имен NameSpase2 */
namespace NameSpase2
{//открывается блок пространста имен NameSpase2
void greeting()
{
cout<<"Privet2"<<endl; //эта функция тоже содержит один оператор
}
}//закрывается блок пространста имен NameSpase2
Void big_greeting() /* определение данной функции не принадлежит ни одному из созданных пространств имен, следовательно дальнейший код помещается в глобальное пространство имен */
{
cout<<"Big greeting";
}
В результате выполнения программы получим следующее
Как следует из рассмотренного примера, используя разные пространства имен можно вызывать разные функции с одинаковыми именами. Областью действия, или как говорят областью видимости директории using является код расположенный между этой директорией и концом блока в котором она находится. Если директория using находится за пределами всех блоков, то она применяется ко всей части файла, следующего после нее. Примером тому может являться using namespace std;
Теперь обратимся к так называемому квалифицированию пространств имен. Предположим, что в нашем распоряжении имеется два пространства имен. Пусть это будут NameSpase1 и NameSpase2.В первом из них определена функция function1, во втором function2. Кроме того, в кажом из этих пространств определена функция My_function. Естественно, что это могут быть разные функции с одинаковым именем. Для работы с двумя функциями function1 и function2 нужно использовать две директивы
using namespace NameSpase1;
using namespace NameSpase2;
однако это приведет к противоречию, возникающему в связи с тем, что функция My_function будет определена дважды. В этом случае необходимо указать, что из пространства имен NameSpase1 будет использоваться только function1,а из пространства имен NameSpase2 будет использоваться только function2 и больше ничего. Это можно сделать используя оператор разрешения области видимости :: (двойное двоеточие).
using NameSpase1 :: function1;
using NameSpase2 :: function2;
Иначе говоря директива вида
using Пространство_имен :: Одно_имя;
представляет доступ к определению имени Одно_имя из пространства имен Пространство_имен, оставляя остальные имена недоступными. Выделение нужных имен из пространства имен, называется квалифицированием.
Теперь представим себе, что нужно всего лишь один или небольшое количество раз использовать определение имени function1 из пространства имен NameSpase1. В таком случае можно имя функции использовать вместе с именем пространства имен, т.е. вызывать функцию так NameSpase1::function1(). Такой способ относится не только к функциям, но и ко всем элементам, входящим в пространство имен. Например, в пространстве имен std определена структура struct1, которую нужно указать в виде параметра некоторой функции MyFunction. Тогда это может выглядеть следующим образом
int MyFunction(struct1);
Здесь мы не только выделили структуру из пространства имен, но и задали тип параметра struct1.
Наконец рассмотрим как ведут себя классы в пространстве имен. Для этого создадим какой-нибудь класс. Рассмотрим например задачу вычисления доходности ценных бумаг. Но сначала поясним, что такое доходность. Пусть, например, мы приобрели вексель по которому в определенный день векселедатель обязуется уплатить некую сумму, которая называется номиналом векселя, который мы обозначим буквой N. Естественно, что покупая вексель мы предполагаем получить доход, т.е. мы купили вексель по цене меньшей номинала (покупка с дисконтом), эту величину обозначим буквой C. Разность между номиналом и ценой покупки это и есть доход - D. Вообще говоря, понятие доход мало о чем говорит. Лучше говорить об относительном доходе, т.е. о доходе отнесенному к затратам (N-C)/C. Обычно относительный доход выражают в процентах
Эта величина показывает какой доход приносит каждый рубль вложенный в ценную бумагу. Но эта величина тоже не говорит об эффективности нашей денежной операции. Одно дело если мы получим такой доход через несколько дней и совсем другое дело если нужно ждать месяцы или даже годы. Иначе говоря, нужно знать какой относительный доход дает ценная бумага каждый день, т.е скорость приносимого дохода. Другими словами, величина
,
где n количество дней с момента покупки до погашения, лучше всего характеризует эффективность сделки. Эту величину уже можно было бы назвать приведенной доходностью, или ежедневным относительным доходом. Однако в экономике принято интересоваться величиной относительного дохода за год, что позволяет сравнить доходность от ценных бумаг с банковским процентом. Поэтому формула расчета доходности выглядит так
Здесь число 365 означает количество дней в году.
Не знаю, поняли вы или нет все хитросплетения экономической мысли, но вполне очевидно одно – в году может быть 366 дней и тогда числитель полученной выше формулы будет иным. Вот именно на этом мы сыграем при исследовании классов в пространстве имен. Сейчас мы создадим два класса, отличающихся только числом дней в году.
#include <iostream>
using namespace std;
//вот первый класс
namespace ns365{//объявление пространства имен ns365
class incom //объявление класса
{public:
double calculator(double nominal,double price,int days);
}; // конец объявления класса
/*описание функции incom, входящей в класс incom1 */
double incom::calculator(double nominal,double price,int days)
{return (((nominal-price)/price)*100*365/days);}
}
//объявление второго классас тем же именем
namespace ns366{//объявление пространства имен ns366
class incom {
public:
double calculator(double nominal,double price,int days);
};// конец объявления класса
/*описание функции incom, входящей в класс incom2 */
double incom::calculator(double nominal,double price,int days)
{return (((nominal-price)/price)*100*366/days);}
}
void main()
{
int daysYear=365, days;
double nominal, price,yield; // yield значит доходность
while (days>0) //организация бесконечного цикла
{
cout<<"Nominal=";
cin>>nominal;
cout<<"Price=";
cin>>price;
cout<<"Number days before repayment=";
cin>>days;
cout<<"Days in year=";
cin>>daysYear;
if (daysYear==365){
ns365::incom inc;//объявление объекта из пространства имен incom1
cout<<"yield="<<inc.calculator(nominal,price,days)<<"%"<<endl;
}
if (daysYear==366){
ns366::incom inc; //объявление объекта из другого
//пространства имен incom2
cout<<"yield="<<inc.calculator(nominal,price,days)<<"%"<<endl;
}
}
}
В данном примере мы создали два практически одинаковых класса. У них одинаковые имена и более того они содержат одноименные функции. Но компьютер различает их благодаря тому, что они помещены в разные пространства имен.
Использование в программировании пространства имен представляет собой относительно новую технологию. Поэтому не все компиляторы поддерживают директиву using.