|
The methods are implictly pure-virtual .
Steve
|
|
|
|
|
Hi Steve,
I have tested that we can put non-pure virtual method,
__interface IFoo {
virtual int foo() = 0;
int goo() {return 0;}
};
Any comments?
regards,
George
|
|
|
|
|
Pure-virtual does ***NOT*** mean the function can have no a body!!!:
#include "stdafx.h"
#include <iostream>
using namespace std;
class YouDontSeeThisOften
{
public:
virtual PureButHasBody() = 0
{
cout << "You don't see this often!" << endl;
}
};
int main(int argc, char* argv[])
{
return 0;
}
Steve
|
|
|
|
|
Hi Steve,
Sorry that I may not make myself understood. My point is, if the link from MSDN, looks like in __interface, we could only put pure virtual method.
But I have tried that put non-pure virtual method (which has method body) is also ok.
Any comments?
regards,
George
|
|
|
|
|
In example you gave the function is pure-virtual , just like in the example I gave. Try to instantiate it and see!
Steve
|
|
|
|
|
No Steve,
The function goo is not pure virtual.
int goo() {return 0;}
Could you review my sample again please?
regards,
George
|
|
|
|
|
I'm afraid it is (pure-virtual ). As I stated earlier, when you use the __interface keyword the functions are pure-virtual implicitly, regardless of whether you use the virtual keyword or put in a = 0 .
Steve
|
|
|
|
|
Thanks Steve,
I think you mean even if the function has body in _interface, it is still treated as pure virtual? How to prove it (is pure virtual)? Looks interesting.
regards,
George
|
|
|
|
|
George_George wrote: I think you mean even if the function has body in _interface, it is still treated as pure virtual?
That’s what I mean, and what I said (“when you use the __interface keyword the functions are pure-virtual implicitly, regardless of whether you use the virtual keyword or put in a = 0”). The whole reason for the __interface keyword is to remove the need for all that syntactic clutter.
George_George wrote: How to prove it (is pure virtual)?
You can prove they're pure by attempting to instantiate one - you should get a compiler error (not a linker error).
Steve
modified on Monday, February 04, 2008 12:25:06 AM
|
|
|
|
|
Thanks Steve,
My question is answered.
regards,
George
|
|
|
|
|
George_George wrote: even if the function has body in _interface, it is still treated as pure virtual
Some clarification is in order: a pure-virtual function can have a body, as I showed in my example code in an earlier post in this thread. The fact that it’s pure just means that it can’t be instantiated and classes that derive from it must override the method or they will not be able to instantiated.
Steve
|
|
|
|
|
Thanks Steve,
I think even if you put the body into a pure virtual function, you can not utilize the function (body), right (for example. invoking it)? During compiling process, it is just discarded?
regards,
George
|
|
|
|
|
George_George wrote: I think even if you put the body into a pure virtual function, you can not utilize the function (body), right (for example. invoking it)? During compiling process, it is just discarded?
You can still call it:
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
public:
virtual void Func() = 0
{
cout << "Base::Func()" << endl;
}
};
class Derived : public Base
{
public:
virtual void Func()
{
cout << "Derived::Func()" << endl;
Base::Func();
}
};
int main(int argc, char* argv[])
{
Derived d;
d.Func();
return 0;
}
Steve
|
|
|
|
|
Hi Stephen,
In your code, you are invoking Func from class Derived. What I mean is you can not utilize Func from class Base. Right?
regards,
George
|
|
|
|
|
George_George wrote: In your code, you are invoking Func from class Derived. What I mean is you can not utilize Func from class Base. Right?
A class with a pure-virtual function can not be instantiated; no more and no less. As this example shows Base can still call it:
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
public:
void CallItForMe()
{
Base::Func();
}
virtual void Func() = 0
{
cout << "Base::Func()" << endl;
}
};
class Derived : public Base
{
public:
virtual void Func()
{
cout << "Derived::Func()" << endl;
}
};
int main(int argc, char* argv[])
{
Derived d;
d.CallItForMe();
return 0;
}
Steve
|
|
|
|
|
Hi Stephen,
Your code is wrong. I am discussing __interface, and if you change your code from class Base to __interface Base, your code can not compile.
Any comments?
regards,
George
|
|
|
|
|
George_George wrote: Your code is wrong. I am discussing __interface, and if you change your code from class Base to __interface Base, your code can not compile.
The same principles apply. Try this if you prefer:
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
public:
virtual void Func() = 0
{
cout << "Base::Func()" << endl;
}
};
class Derived : public Base
{
public:
virtual void Func()
{
cout << "Derived::Func()" << endl;
}
};
int main(int argc, char* argv[])
{
Derived d;
d.Base::Func();
return 0;
}
Steve
|
|
|
|
|
Try what, Steve?
If you change code from class Base to __interface Base, your code can not compile. Your above code still use class other than __interface.
regards,
George
|
|
|
|
|
The compiler I using now doesn't support the __interface keyword, but perhaps this is more to your liking:
#include "stdafx.h"
#include <iostream>
using namespace std;
__interface Base
{
void Func()
{
cout << "Base::Func()" << endl;
}
};
class Derived : public Base
{
public:
virtual void Func()
{
cout << "Derived::Func()" << endl;
}
};
int main(int argc, char* argv[])
{
Derived d;
d.Base::Func();
return 0;
}
Steve
|
|
|
|
|
It is ok, Steve!
I have tested that your code can compile and generates the expected result. I think it really conflicting to what you have said before -- even if you add body to pure virtual function body, the body does not take any effect or something like this.
Any comments?
regards,
George
|
|
|
|
|
For the last time, for this is getting receptive:
The pure-virtual ness of a function and whether or not it contains a body are independent issues. The body, if present, is not ignored by the compiler, be the function virtual or pure-virtual . I posted code that explicitly demonstrated this.
Steve
|
|
|
|
|
Thanks Steve,
I have got your point, which is, in __interface we can put function body and implement and non-pure virtual function, and the function body is not ignored by compiler. Right?
Just a little confused,
"The pure-virtualness of a function and whether or not it contains a body are independent issues."
Why do you say it is independent issue?
regards,
George
|
|
|
|
|
George_George wrote: I have got your point, which is, in __interface we can put function body and implement and non-pure virtual function, and the function body is not ignored by compiler. Right?
Yes, as the examples I've given have shown.
George_George wrote: "The pure-virtualness of a function and whether or not it contains a body are independent issues."
Why do you say it is independent issue?
If a class has functions that are pure-virtual it just means the compiler will refuse to instantiate it, if the function has a body or not is of no bearing.
Steve
|
|
|
|
|
Thanks Steve,
My question is answered. It is good to learn from you that a pure-virtual function could have body and in some situations we could take use of it.
regards,
George
|
|
|
|
|
I think u can call that function using Scope resolution
|
|
|
|