]]>
#include <iostream.h>
class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};
void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3 (surprise!)
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
}
class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
};
void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); // Derived::f(float) 3.14
pd->f(3.14f); // Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); // Base::g(float) 3.14
pd->g(3.14f); // Derived::g(int) 3 (surprise!)
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
}
class Base
{
public:
void f(int x);
};
class Derived : public Base
{
public:
void f(char *str);
};
void Test(void)
{
Derived *pd = new Derived;
pd->f(10); // error
//why? just imagine multiple inheritance
}
{
public:
void f(int x);
};
class Derived : public Base
{
public:
void f(char *str);
};
void Test(void)
{
Derived *pd = new Derived;
pd->f(10); // error
//why? just imagine multiple inheritance
}
]]>
cout<< sizeof(a) << endl; // 4 瀛楄妭鑰屼笉鏄?00 瀛楄妭
}
]]>
int atexit ( void ( * function ) (void) ); <cstdlib>
The function pointed by the function pointer argument is called when the program terminates normally.
If more than one atexit function has been specified by different calls to this function, they are all executed in reverse order as a stack, i.e. the last function specified is the first to be executed at exit.
One single function can be registered to be executed at exit more than once.
C++ implementations are required to support the registration of at least 32 atexit functions.
Parameters
- function
- Function to be called. The function has to return no value and accept no arguments.
Return Value
A zero value is returned if the function was successfully registered, or a non-zero value if it failed.
Example
/* atexit example */ #include <stdio.h> #include <stdlib.h> void fnExit1 (void) { puts ("Exit function 1."); } void fnExit2 (void) { puts ("Exit function 2."); } int main () { atexit (fnExit1); atexit (fnExit2); puts ("Main function."); return 0; } |
Output:
Main function.
|
]]>
In C++, it is the order of the class inheritance and of the member variables that determine the initialization order, not the order of an initializer list:
#include <iostream>class CSomeClass
{
public:CSomeClass(int n)
{std::cout << "CSomeClass constructor with value ";std::cout << n << std::endl;
}
};class CSomeOtherClass{public:CSomeOtherClass() //In this example, despite the list order,: obj2(2), obj1(1) //obj1 will be initialized before obj2.{//Do nothing.}private:CSomeClass obj1;CSomeClass obj2;};int main(void){CSomeOtherClass obj;return 0;}]]>