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]

mosfet wrote:

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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Kira Yamato]

On 2008-01-03 11:02:00 -0500, mosfet <jo******@anonymous.orgsaid:

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();

--

-kira

[mosfet]

Victor Bazarov a écrit :

mosfet wrote:

>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

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

[Victor Bazarov]

mosfet wrote:

Victor Bazarov a écrit :

>mosfet wrote:

>>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

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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[shaun roe]

In article <2008010311314116807-kirakun@earthlinknet>,
Kira Yamato <ki*****@earthlink.netwrote:

On 2008-01-03 11:02:00 -0500, mosfet <jo******@anonymous.orgsaid:

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();

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]

shaun roe wrote:

In article <2008010311314116807-kirakun@earthlinknet>,
Kira Yamato <ki*****@earthlink.netwrote:

>On 2008-01-03 11:02:00 -0500, mosfet <jo******@anonymous.orgsaid:

>>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();

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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[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]

Rahul wrote:

>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...

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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Rahul]

On Jan 3, 10:22 pm, "Victor Bazarov" <[e-mail]:

Rahul wrote:

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...

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
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

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...