another question about virtual functions

[SuperNewbie]

Hi

I found that don't affect the derived class.

if a virtual method is defined with "private" or "procted", the derived class still can implement it, right? So doesn't make it sense to put "private" or "procted" in front of virtual methods in deriving class?

Thanks

[cgod]

A class wich is deriving from another one will not be able to see private data, if you dont declare what the data is it be automatically private.

[SuperNewbie]

Sorry, seems I didn't make myself clear:

for example:

#include <iostream.h>
class A
{
    private:
            virtual void test(){return;}
            virtual void test2()=0;
};

class B : public A
{
     public:
           void test(){cout<<"replaced by B"<<endl;}
           void test2(){cout<<"implement by B"<<endl;}
};
void main()
{
      //implenment!!
      B* b = new B;
      b->test();
      b->test2();
}

I compiled it and no error. My question is that even 2 "test" functions are declared as private or protected, but they are still can be modified. so "private" doesn't restrcit the access.

Thanks again

sorry for the mistake, now it really compiles with no error

[Sang-drax]

But there is no possibility to call either A::test() or A::test2() from outside A, so the private access still holds.

[SuperNewbie]

But there is no possibility to call either A::test() or A::test2() from outside A, so the private access still holds

If I understand right, this is for common case because test2() is pure virtual function and test() is not static. So nothing about "private", right?

[Sang-drax]

So nothing about "private", right?

I'm not sure I understand, but if you hadn't declared the methods private, B would've been able to do:

A::test();

[quzah]

Except that there is no 'test1', and if it were 'test', 'test' is a pure virtual funciton, and as such, has no actual function you can invoke. Right?

Quzah.

[Sang-drax]

Hmm, I was almost certain I edited 'test1' to 'test' just after posting.
I meant test() and it is not a pure virtual function. Only test2() is pure virtual.

(ignoring errors like a void function returning 0 etc.)

[quzah]

Right. I could have sworn test was the pure virtual function, and test2 wasn't. Anyway, we can both agree on if there is a pure virtual function in there some place, you can't call it. But you could call non-private non-virtual functions.

Quzah.

[Kleid-0]

I can't grasp what concept you guys are trying to understand. What I get from this is is that the private virtual functions are completely useless:

#include <iostream>

using std::cout;
using std::endl;

class A
{
   private:
      virtual void test1( )
      {
         cout << "Yo yo" << endl;
      }
   
      virtual void test2( )
      {
         cout << "Blah blah blah" << endl;   
      }
};

class B : public A
{
   public:
      void test1( )
      {
         cout << "replaced by B" << endl;
      }
   
      void test2( )
      {
         cout << "implement by B" << endl;
      }
};

int main( )
{
   // Test out classes
   
   B* b = new B;
   b->test1();
   b->test2();

   // Return success

   return 0;
}

[skorman00]

Private will not allow any children to touch the function, but virtual will allow them to ovveride it. So classB can have it's own test(), but cannot call the test that is in classA (If they were public, then classB would be able to call classA's).

The only situation I can think of that will allow you to understand what's going on would be to create a class that is a friend of both classA and classB, and then test out what happens when it calls the private functions using different pointers.

[SuperNewbie]

Sorry for confusing you guys, but here I make the conclusion according to my point of view:

Private will not allow any children to touch the function, but virtual will allow them to ovveride it.

Right, private and virtual they are totally different and nothing to do each other:

private emphasizes on its own members, means that no other derived classes or instance (or even deriving class instance) can access them, but the deriving class itself.

virtual emphasizes on the override and implementation, so even the pure virtual function is tagged as "private" in deriving class must be implemented by its sub class if the sub class has its instance. (notice the difference between virtual and pure virtual)

So the "private virtual" I think it doesn't make any sense here

So the new problem is for example:

what would the situation if:

class B: public A
and
class B: protected A
and
class B: private A

I think those happen unfrequently, but it is still good if we know it.

[Sang-drax]

Try the following code:

class A {
  private:
    virtual void test() { cout<<"test from A"; }
  public:
    void doSomething() { test(); }
};

class B: public A {
  virtual void test() {cout << "test from B";}
};

int main()  {
  A* obj = new B;
  obj.doSomething();
}

[SuperNewbie]

I think virtual function can be override no matther if it is "private" or not because private means only the other members in the same class can invoke it. so

class B: public A

where

virtual void test()

in A has been overrided.

int main()  {
  A* obj = new B; // object ONLY has the function doSomething()
  obj->doSomething(); // test() in A has been overrided already, 
                                  //so use test() in B class!!
  return 1;
}

Right??

[Sang-drax]

I think virtual function can be override no matther if it is "private" or not because private means only the other members in the same class can invoke it.

Yes, that's correct.