calling class method

[mosfet]

Hi,

Let's say I have two classes A and B with B inheriting from A
with one non virtual method :


class A
{
public:

void MethodA()
{
cout << "MethodeA in class A" << endl
}
};


class B : public class A
{
public:

void MethodA()
{
cout << "MethodeA in class B" << endl
}
};




int main()
{

B testB;

testB.MethodA(); // Should display "MethodeA in class B"

}


IF I try this example the MethodA from class B will be called.
And what if I want from a B object to call the A implementation ? Is it
possible ?

 

[Victor Bazarov]

Let's say I have two classes A and B with B inheriting from A
with one non virtual method :


class A
{
public:

void MethodA()
{
cout << "MethodeA in class A" << endl
}
};


class B : public class A
{
public:

void MethodA()
{
cout << "MethodeA in class B" << endl
}
};




int main()
{

B testB;

testB.MethodA(); // Should display "MethodeA in class B"

}


IF I try this example the MethodA from class B will be called.
And what if I want from a B object to call the A implementation ? Is
it possible ?

Yes, do

testB.A::MethodA();

HTH

V

 

[Kira Yamato]

Hi,

Let's say I have two classes A and B with B inheriting from A
with one non virtual method :


class A
{
public:

void MethodA()
{
cout << "MethodeA in class A" << endl
}
};


class B : public class A
{
public:

void MethodA()
{
cout << "MethodeA in class B" << endl
}
};




int main()
{

B testB;

testB.MethodA(); // Should display "MethodeA in class B"

}


IF I try this example the MethodA from class B will be called.
And what if I want from a B object to call the A implementation ? Is it
possible ?

testB.A::MethodA();

 

[mosfet]

Victor Bazarov a écrit :

Yes, do

testB.A::MethodA();

HTH

V

Does it mean that a running B object holds also A methods it has
redefined or is it done at compilation time ?

 

[Victor Bazarov]

Victor Bazarov a écrit :
Does it mean that a running B object holds also A methods it has
redefined or is it done at compilation time ?

A "running B object"? "Holds"? Not sure what you mean by all these
terms, sorry. The functions do not go anywhere. The calls are
resolved at compile time (since your functions are non-virtual).
The name resolution is a well defined process. Since 'B' inherits
from 'A', any members of 'A' are also members of 'B', and you can
call them, nothing to it. You only need to let your compiler know
where to find the member function you need to call.

V

 

[shaun roe]

testB.A::MethodA();

like so?:

#include <iostream>
using namespace std;

class A{
public:
void methodA(){
cout << "Method A in class A" << endl;
}
};


class B : public A{
public:
void methodA(){
cout << "Method A in class B" << endl;
}
void methodAfromA(){
A::methodA();
}
};


int main (int argc, char * const argv[]) {
// insert code here...
std::cout << "Hello, World!\n";
B testB;

testB.methodA(); // Should display "Method A in class B"
testB.methodAfromA();
return 0;
}

 

[Victor Bazarov]

testB.A::MethodA();

like so?:

#include <iostream>
using namespace std;

class A{
public:
void methodA(){
cout << "Method A in class A" << endl;
}
};


class B : public A{
public:
void methodA(){
cout << "Method A in class B" << endl;
}
void methodAfromA(){
A::methodA();
}
};


int main (int argc, char * const argv[]) {
// insert code here...
std::cout << "Hello, World!\n";
B testB;

testB.methodA(); // Should display "Method A in class B"
testB.methodAfromA();
return 0;
}

Why bother with all this? Just do as Kira has suggested, in the
'main' function:

int main() {
B testB;
testB.A::MethodA();
}

Or do you have a problem with that?

V

 

[Rahul]

A "running B object"? "Holds"? Not sure what you mean by all these
terms, sorry. The functions do not go anywhere. The calls are
resolved at compile time (since your functions are non-virtual).
The name resolution is a well defined process. Since 'B' inherits

Well, the calls to even a virtual function would be resolved at
compile time, if they are called using the object rather than the
pointers...

 

[Victor Bazarov]

Well, the calls to even a virtual function would be resolved at
compile time, if they are called using the object rather than the
pointers...

Yes, in this case they are. Just to emphasize, calls to non-virtual
functions are _always_ resolved at compile time regardless of how the
call is made, from a pointer, a reference, or an object. It probably
is the question of how it's implemented: do you check the virtuality
first or whether it's called through a pointer/reference or an object
first...

V

 

[Rahul]

Yes, in this case they are. Just to emphasize, calls to non-virtual
functions are _always_ resolved at compile time regardless of how the
call is made, from a pointer, a reference, or an object. It probably
is the question of how it's implemented: do you check the virtuality
first or whether it's called through a pointer/reference or an object
first...

V

Yes, and the irony being that even a call to virtual functions with a
pointer or a reference is taken care in compile time with the help of
function pointers, a kind of relative call (from the begining of
VTABLE)... if i'm correct, this is often done by the static linker...