#include "stdafx.h"

class Parent
{
public:
    virtual void print(int x)
    {
        printf("%d", x);
    };
};

class Child: public Parent
{
    virtual void print(int x, int y)
    {
        printf("%d %d", x, y);
    };
};

int _tmain(int argc, _TCHAR* argv[])
{
    Child child;
    child.print(10);
    return 0;
}

<source>:24:11: error: 'print' is a private member of 'Child'
24 | child.print(10);
| ^
<source>:15:18: note: implicitly declared private here
15 | virtual void print(int x, int y)
| ^
<source>:24:11: error: too few arguments to function call, expected 2, have 1; did you mean 'Parent::print'?
24 | child.print(10);
| ^~~~~
| Parent::print
<source>:6:18: note: 'Parent::print' declared here
6 | virtual void print(int x)
| ^
2 errors generated.
Compiler returned: 1

S>#include "stdafx.h"

S>class Parent
S>{
S>public:
S>    virtual void print(int x)
S>    {
S>        printf("%d", x);
S>    };
S>};

S>class Child: public Parent
S>{
S>    virtual void print(int x, int y)
S>    {
S>        printf("%d %d", x, y);
S>    };
S>};

S>int _tmain(int argc, _TCHAR* argv[])
S>{
S>    Child child;
S>    child.print(10);
S>    return 0;
S>}

S>

public:
    using Parent::print;

#include <iostream>
#include <source_location>

std::string current_function(std::source_location location = std::source_location::current()) {
    return location.function_name();
}

struct Base
{
    void foo() const { std::cout << current_function() << std::endl; }
    void foo(int) const { std::cout << current_function() << std::endl; }
    void foo(int, int) const { std::cout << current_function() << std::endl; }
    void foo(int, int, int) const { std::cout << current_function() << std::endl; }
};

struct Derived : Base
{
    using Base::foo;
    void foo(int) const { std::cout << current_function() << std::endl; }
};

int main() {
    Derived d;

    d.foo();
    d.foo(1); // void Derived::foo(int) const
    d.foo(1, 2);
    d.foo(1, 2, 3);
}