namespace libs R us { int max( int, int ); int max( double, double );

extern void print( int ); extern void print( double );

using-объявления using libs R us::max;

using libs R us::print( double ); ошибка

void func() {

max( 87, 65 ); вызает libs R us::max( int, int )

объявление встречается. Что делают такие объявления в следующей программе? max( 35.5, 76.6 ); вызывает libs R us::max( double, double )

Первое using-объявление вводит обе функции libs R us::miax в глобальную область видимости. Теперь любую из функций max() можно вызвать внутри func() . По типам аргументов определяется, какую именно функцию вызывать. Второе using-объявление -это ошибка: в нем нельзя задавать список параметров. Функция libs R us::print() объявляется только так:

using libs R us::print;

Using-объявление всегда делает доступными все перегруженные функции с указанным именем. Такое ограничение гарантирует, что интерфейс пространства имен libs R us не будет нарушен. Ясно, что в случае вызова

print( 88 );

автор пространства имен ожидает, что будет вызвана функция libs R us::print(int) . Если разрешить пользователю избирательно включать в область видимости лишь одну из нескольких перегруженных функций, то поведение программы становится непредсказуемым.

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

Использование using-объявлений и using-директив помогает сделать члены пространства имен доступными в других областях видимости. Эти механизмы оказывают определенное влияние на объявления перегруженных функций. (Using-объявления и using-директивы рассматривались в разделе 8.6.)

Каким образом using-объявление сказывается на перегрузке функций? Напомним, что оно вводит псевдоним для члена пространства имен в ту область видимости, в которой это

#include <string> namespace libs R us {

extern void print( int );

extern void print( double );

extern void print( const string & );

using libs R us::print;

void fooBar( int ival )

/ libs R us::print( int ) и libs R us::print( double ) перегружают print( const string & )

print( Value: ); вызывает глобальную функцию

print( const string & ) print( ival ); вызывает libs R us::print( int )

Using-объявление добавляет в глобальную область видимости два объявления: для print(int) и для print(double) . Они являются псевдонимами в пространстве libs R us и включаются в множество перегруженных функций с именем print, где уже находится глобальная print(const string &) . При разрешении перегрузки print в fooBar рассматриваются все три функции.

Если using-объявление вводит некоторую функцию в область видимости, в которой уже имеется функция с таким же именем и таким же списком параметров, это считается ошибкой. С помощью using-объявления нельзя задать псевдоним для функции print(int) в пространстве имен libs R us, если в глобальной области видимости уже

libs R us {

namespace

void print( int ); void print( double );

void print( int );

using libs R us::print; ошибка: повторное объявление print(int)

void fooBar( int ival ) {

print( ival ); какая print? ::print или libs R us::print

есть print(int) . Например:

М1 показали, как связаны using-объявления и перегруженные функции. Теперь рассмотрим особенности применения using-директивы. Using-директива приводит к тому, что члены пространства имен выглядят объявленными вне этого пространства, добавляя их в новую область видимости. Если в этой области уже есть функция с тем же именем, то происходит перегрузка. Например:

#include <string> namespace libs R us {

extern void print( int ); extern void print( double );

extern void print( const string & ); using-директива

print(int), print(double) и print(const string &) - элементы одного и того же множества перегруженн функций using namespace libs R us;

void fooBar( int ival ) {

print( Value: ); вызает глобальную функцию

print( const string & ) print( ival ); вызывает libs R us::print( int )

Это верно и в том случае, когда есть несколько using-директив. Одноименные функции,

namespace IBM { int print( int );

amespace Disney double print( d

namespace

double );

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

using-директива

формируется множество перегруженн функций из разичн пространств имен using namespace IBM; using namespace Disney;

long double print(long double);

int main() {

print(1); вызывается IBM::print(int)

print(3.1); вызывается Disney::print(double)

return 0;

Множество перегруженных функций с именем print в глобальной области видимости включает функции print(int), print(double) и print(long double) . Все они рассматриваются в main() при разрешении перегрузки, хотя первоначально были определены в разных пространствах имен.

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