разница между сокрытием функции и перегрузкой
Я не могу найти никакой разницы между скрытием функций и перегрузкой. Поскольку функция скрытия — это функция, которая присутствует в производном классе и скрывает функцию базового класса. Имея одинаковое имя функции в них обоих.
Перегрузка: с одинаковым именем, но разной подписью как в производном, так и в базовом классе.
class A {
void print(int);
};
class B: public A {
void print(float);
};
это скрывает функцию или перегрузку?
Решение
Функция B::print шкуры родительская функция A::print,
Если хотите перегрузка вам нужно тянуть в A::print функция в сферу B:
class B : public A {
public:
using A::print; // Pull in (all) A::print symbols into the scope of B
void print(float); // Now overloads A::print
};
Другие решения
Имя, определенное в области видимости шкуры объявления с одинаковым именем в любой внешней области видимости. Как это:
int name; // global name
void f() {
int name; // name 1, hides global name
for (int i = 0; i < 10; i++) }
int name; // name 2, hides name 1 and global name
name = 3; // assigns 3 to name 2
}
name = 4; // assigns 4 to name 1
}
int other = name; // copies value of global name into other
Когда две или более функции с одинаковым именем объявлены в том же объеме, имя перегружено:
// two functions in global scope:
void f();
void f(int);
void g() {
f(); // ok: calls first version of f
f(1); // ok: calls second version of f
}
Определения в разных областях не определять наборы перегрузки, потому что объявление во внутренней области видимости скрывает то же имя в любой внешней области видимости.
class cl1 {
public:
// hides global f's:
void f();
void g() {
f(); // ok: calls cl1::f()
f(1); // error: no f takes an int; global f(int) is hidden
}
};
Конечно, определение нескольких функций в одной и той же области действия по-прежнему определяет перегрузки, даже если во внешней области есть функции с одним и тем же (скрытым) именем.
class cl2 {
public:
// these hide global f's, and provided overloads:
void f();
void f(int);
void g() {
f(); // calls cl2::f()
f(1); // calls cl2::f(int)
}
};
Определение класса предоставляет новую область видимости, поэтому правила скрытия и перегрузки имен применяются к именам, определенным в классе.
class cl3 : public cl2 {
void g() {
f(); // calls cl2::f()
f(1); // calls cl2::f(int)
}
};
class cl4 : public cl2 {
// hides all f's:
void f();
void g() {
f(); // ok: calls cl4::f();
f(3); // error: no f takes an int; global f(int) and cl2::f(int) are hidden
}
};
class cl5 : public cl2 {
// hides all f's and provides overloads:
void f();
void f(int);
void g() {
f(); // ok: calls cl5::f()
f(3); // ok: calls cl5::f(int)
}
};
Вы также можете использовать подпись, которая не соответствует ни одной из подписей в базовом классе. В конце концов, имя этих функций базового класса скрыто.
class cl5 : public cl2 {
public:
// hides all f's:
void f(std::string);
void g() {
f(); // error: no f taking no arguments
f(3); // error: no f taking int
std::string arg("test");
f(arg); // ok: calls cl5::f(std::string)
}
};
И, наконец, если вы хотите написать производный класс, который добавляет сигнатуры к набору перегруженных функций, определенных в базовом классе, вы должны добавить имя этих перегруженных функций в производный класс:
class cl6 : public cl2 {
public:
using cl2::f; // pull cl2::f into current scope
void f(std::string); // add overload to names from cl2
void g() {
f(); // ok: calls cl2::f()
f(3); // ok: calls cl2::f(int)
std::string arg("test");
f(arg); // ok: calls cl6::f(std::string)
}
};
detector