1.Below is usual way we find one element in an array:
const int *find1(const int* array, int n, int x)
{
    const int* p = array;
    for(int i = 0; i < n; i++)
    {
        if(*p == x)
        {
            return p;
        }
        ++p;
    }
    return 0;
}
In this case we have to bear the knowledge of value type "int", the size of
array,
even the existence of an array. Would you re-write it using template to elim
inate all
these dependencies?
2. Assume you have a class like
class erp
{
    HR* m_hr;
    FI* m_fi;
public:
    erp()
    {
        m_hr = new HR();
        m_fi = new FI();
    }
    ~erp()
    {
    }
};
if "new FI()" failed in the constructor, how can you detect this problem and
release the
properly allocated member pointer m_hr?
3. Check the class and variable definition below:
#include <iostream>
#include <complex>
using namespace std;
class Base
{
public:
    Base() { cout<<"Base-ctor"<<endl; }
    ~Base() { cout<<"Base-dtor"<<endl; }
    virtual void f(int) { cout<<"Base::f(int)"<<endl; }
    virtual void f(double) {cout<<"Base::f(double)"<<endl; }
    virtual void g(int i = 10) {cout<<"Base::g()"<<i<<endl; }
};
class Derived: public Base
{
public:
    Derived() { cout<<"Derived-ctor"<<endl; }
    ~Derived() { cout<<"Derived-dtor"<<endl; }
    void f(complex<double>) { cout<<"Derived::f(complex)"<<endl; }
    virtual void g(int i = 20) {cout<<"Derived::g()"<<i<<endl; }
};
Base b;
Derived d;
Base* pb = new Derived;
Select the correct one from the four choices:
Cout<<sizeof(Base)<<endl;
A. 4    B.32    C.20    D.Platform-dependent
Cout<<sizeof(Base)<<endl;
A. 4    B.8 C.36    D.Platform-dependent
pb->f(1.0);
A.Derived::f(complex)   B.Base::f(double)
pb->g();
A.Base::g() 10      B.Base::g() 20
C.Derived::g() 10   D.Derived::g() 20
4.Implement the simplest singleton pattern(initialize if if necessary).
5.Name three sort algorithms you are familiar with. Write out the correct or
der by the
average time complexity.
6.Write code to sort a duplex direction linklist. The node T has overridden
the comparision operators