Two conceptual questions

Hi there, I was trying to summary some basic conceptions about class inheritance and I am not 100% sure about my answer to the following two questions. Please point out if my answer is wrong. And any suggestions and comments appreciated :)

1. if the base class uses "new" to dynamic allocate memory
the copy constructor for the base class is marked as protected and
the derived class doesn't have any member which needs dynamic memory allocation
does the derived class need an explicit copy constructor? //NO
Also, the copy assignment operator for base class should be marked as public and the derived class doesn't need an explicit copy assignment operator declaration

2. a declaration of function with same name and different signature in the derived class can hide functions defined in base class with same name. In following two situations:
Situation1:

Code:

---

//base class
class base{
  public:
      virtual void func();    //#1
      virtual void func(int);  //#2
      virtua void func(int, int);  //#3
//...
};

//derived class A
class A: public base{
  public:
      virtual void func(int, int, int)
//...
};

---

#1, #2, #3 functions are all hiden in the derived class
then, for a pointer or reference of the base class (which may point or refer to the derived class object), ptr or rf, are the following statement valid?

Code:

---

      ptr->func(); //#4 invalid 
      ra.func(3, 5); //#5 invalid

---

also if class B derived from classA,which may define functions like #1, #2, #3, even, ptr actually points the a classB object, statements #4 and #5 will be still invalid.

Situation 2:

Code:

---

//base class
class base{
  public
      virtual void func();    //#1
      virtual void func(int);  //#2
      virtua void func(int, int);  //#3
};

//derived class
class A : public base{
void func(int)
};

---

if the derived class just redefines #2,. will #1 and #3 inherited? //yes
are statements #4 and #5 valid?
ptr->func(); //valid
ra.func(3, 5); //valid
also , can a derived class object still invoke function #1 and #3? //yes

Quote:

---

1. if the base class uses "new" to dynamic allocate memory
the copy constructor for the base class is marked as protected and
the derived class doesn't have any member which needs dynamic memory allocation
does the derived class need an explicit copy constructor? //NO
Also, the copy assignment operator for base class should be marked as public and the derived class doesn't need an explicit copy assignment operator declaration

---

I would expect in such situations it is the base class that needs both a copy constructor and an assignment operator (unless instances of the whole hierarchy are not meant to be copyable). Then, if copying the derived class's part is trivial, it shouldn't need any special treatment.

Quote:

---

2. a declaration of function with same name and different signature in the derived class can hide functions defined in base class with same name...

---

You can access the base class versions through a base pointer and the derived class func version through a pointer to derived instance.
In addition, given a derived instance, you should be able to call the base class versions by explicitly stating so:

Code:

---

    A a;
    a.base::func();

---

However, having shadowed virtual functions kind of seems to defeat the purpose of a virtual function, making it hard to make truly polymorphic function calls.

Shadowing virtual functions is considered very bad practice in general.

That said, I have a hard time knowing where the questions and your answers are in your post.

Shadowing is a matter of lookup. Given base, A and B from situation 1:

Code:

---

B *pb = new B();
A *pa = pb;
base *pbas = pa;

// Too lazy to correct my typo from foo to func now.
pb->func(); // Valid, calls B::foo()
pb->func(1); // Valid, calls B::foo(int)
pb->func(1, 2); // Valid, calls B::foo(int, int)
pb->func(1, 2, 3); // Invalid, A::foo(int, int, int) is hidden

pa->func(); // Invalid, base::foo() is hidden
pa->func(1); // Invalid, base::foo(int) is hidden
pa->func(1, 2); // // Invalid, base::foo(int, int) is hidden
pa->func(1, 2, 3); // Valid, calls A::foo(int, int, int)

pa->base::func(1, 2); // Valid, but beware! Calls base::func(int, int), not B::func(int, int)!

pbas->func(); // Valid, calls B::foo()
pbas->func(1); // Valid, calls B::foo(int)
pbas->func(1, 2); // Valid, calls B::foo(int, int)
pbas->func(1, 2, 3); // Invalid, No such function in base.

---

For situation 2:

Code:

---

pa->func(); // Invalid, base::func() is hidden
pa->func(1); // Valid, calls A::func(int)
pa->func(1,2); // Invalid, base::func(int, int) is hidden

pbas->func(); // Valid, calls base::func()
pbas->func(1); // Valid, calls A::func(int)
pbas->func(1, 2); // Valid, calls base::func(int, int)

---

thank both of you for replies.
That makes sense to me