c++ issue with function overloading in an inherited class

This is possibly a noob question, sorry about that. I faced with a weird issue recently when trying to mess around with some high level stuff in c++, function overloading and inheritance.

I'll show a simple example, just to demonstrate the problem;

There are two classes, classA and classB, as below;

class classA{
	public:
		void func(char[]){};	
};

class classB:public classA{	
	public:
		void func(int){};
};

According to what i know classB should now posses two func(..) functions, overloaded due to different arguments.

But when trying this in the main method;

int main(){
	int a;
	char b[20];
	classB objB;
	objB.func(a);    //this one is fine
	objB.func(b);    //here's the problem!
	return 0;
}

It gives errors as the method void func(char[]){}; which is in the super class, classA, is not visible int the derived class, classB.

How can I overcome this? isn't this how overloading works in c++? I'm new to c++ but in Java, i know I can make use of something like this.

Though I've already found this thread which asks about a similar issues, I think the two cases are different.

All you need is a using:

class classB:public classA{ 
    public:
        using classA::func;
        void func(int){};
};

It doesn't search the base class for func because it already found one in the derived class. The using statement brings the other overload into the same scope so that it can participate in overload resolution.

It is well explained for example in this question's answers:

https://stackoverflow.com/questions/1896830/why-should-i-use-the-using-keyword-to-access-my-base-class-method

In short, compiler will stop searching for matching methods from parent classes, when it finds matching method name in current class, even when that method is not compatible. I guess this allows some automatic type conversions to work more logically, without needing to override so many parent class methods.

If you override one variant of a function in the derived class, you need to override all variants. You can either use what JLledo suggested or write the variant of the function in the derived class which simply calls the base class's function of same signature.

class classA{
    public:
        void func(char[]){};    
};

class classB:public classA{ 
    public:
        void func(int){};
        void func(char[]){};
};

void classB:func(char[] ch)
{
    classA::func(ch);
}

The solution proposed provides a maintenance headache. Injecting a using A::func into a derived class requires that rearchitecting software be sensitive to using clauses placed in derived classes, that is, rather than changing a base class by itself the maintainer has to also change a derived class. Suppose we go from base<-derived1 to base<-derived2<-derived1. Now a using clause, using base::func must be changed to using derived2::func, forcing consideration of using clauses and increasing the cost of maintenance. Saying that this has been in the C++ standardizing effort for quite some time doesn't change that the idea seems ill-conceived. It interrupts the notion of inheritance. Just my thought on this.

You must pass the argument of type int in

objB.func(b);    //here's the problem!

bcs it has been overloaded with int argument