|
How to change the height of toolbar control in win32.
Thanks
|
|
|
|
|
toolbar control height is determined by the height of the button in it.
if you are using CreateToolbarEx API to create toolbar then dyButton parameter represents the height of button
|
|
|
|
|
|
Hello everyone,
Seems when using __interface to define a C++ interface in Visual Studio, we can provide non-pure virtual function. Previously I think in interface, only pure virtual function is allowed. Seems there is no such restriction now.
Correct?
thanks in advance,
George
|
|
|
|
|
See here[^]. When you use the __interface keyword these details are taken care of automatically: The functions are still pure-virtual , you just don't need to do so explictly.
Steve
|
|
|
|
|
Hi Steve!
I have read the link before asking this question. The link said, "Can only contain public, pure virtual methods". But I have tried that it could contain non-pure virtual methods.
Any ideas?
regards,
George
|
|
|
|
|
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
|
|
|
|