Re: Operator= can't be inherited.
On Feb 11, 3:42 am, Nephi Immortal <immortalne...@gmail.com> wrote:
On Feb 10, 7:09 am, James Kanze <james.ka...@gmail.com> wrote:
On Feb 10, 5:06 am, Nephi Immortal <immortalne...@gmail.com> wrote:
Please explain why operator= cannot be inherited into class
B from class A.
For the same reason other functions aren't be inherited if you
define a function with the same name in the derived class.
Is it because the left reference before operator= is type A,
but not type B? Then, do I have to define a copy of operator=
and replace left reference to type B in class B body?
It's more because every class has an operator=; if you don't
define one, the compiler will do it for you.
It is annoying to redefine operator= every time I create
several new classes that are derived from class A.
I'm not sure what you're trying to accomplish, but assignment
and inheritance don't generally work well together to begin
with.
Ok. I understand, but I want to ask why operator= can't be
inherited.
For the same reason no function is inherited if you declare
a function of the same name in the derived class. operator=
follows exactly the same rules as every other function.
Consider:
struct Base
{
void f(int);
void f(std::string const&);
};
struct Derived : Base
{
void f(std::string const&);
};
int
main()
{
Derived d;
d.f(1);
return 0;
}
Doesn't compile either. (Worse, d.f(0) compiles, but crashes at
runtime, because it tries to convert the null pointer constant
into a string, in order to call d.f(std::string const&).)
See http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.9=
..
For example, Object &operator=( const Object & ) cannot be inherited
and it is provided to all classes by C++ Compiler unless you define
your own operator= explicitly.
Now, I am asking. What about Object &operator=( const int )? It is
not provided by C++ Compiler and it should be inherited.
Declaring any function with a given names in a derived class
blocks the inheritance of all functions of that name. This is
a basic principle of C++ name lookup: once the compiler finds
a name, it stops.
Also, and what about operator int() as cast operator? Can it be
inherited?
And what about other operators such as operator[], operator++, and
operator+=?
Operators follow exactly the same rules as any other function.
With no exceptions.
--
James Kanze