using namespace std;
/* function that compares two pointers by comparing the values to which they point
聽*/
bool int_ptr_less (int* a, int* b)
{
聽聽聽 return *a < *b;
}
int main()
{
聽聽聽 int x = 17;
聽聽聽 int y = 42;
聽聽聽 int* px = &x;
聽聽聽 int* py = &y;
聽聽聽 int* pmax;
聽聽聽 // call max() with special comparison function
聽聽聽 pmax = max (px, py, int_ptr_less);
聽聽聽 //...
}
榪欐槸婧愪唬鐮?MSVC7):
template<class _Ty,
聽class _Pr> inline
聽const _Ty& _MAX(const _Ty& _Left, const _Ty& _Right, _Pr _Pred)
聽{聽// return larger of _Left and _Right using _Pred
聽return (_Pred(_Left, _Right) ? _Right : _Left);
聽}
2.璁劇疆boolalpha鍙互璁╂祦杈撳嚭bool鍊肩殑瀛楃涓插艦寮?/p>
聽cout << boolalpha ;
聽bool b = true;
聽cout << b <<"*********"<<!b << endl;
緇撴灉:
true*********false
3銆備竴涓嬩唬鐮佸彲浠ユ祴璇曚綘鐨勭郴緇熷悇綾誨瀷鐨勮寖鍥?br />#include <iostream>
#include <limits>
#include <string>
using namespace std;
int main()
{
聽聽 // use textual representation for bool
聽聽 cout << boolalpha;
聽聽 // print maximum of integral types
聽聽 cout << "max(short): " << numeric_limits<short>::max() << endl;
聽聽 cout << "max(int):聽聽 " << numeric_limits<int>::max() << endl;
聽聽 cout << "max(long):聽 " << numeric_limits<long>::max() << endl;
聽聽 cout << endl;
聽聽 // print maximum of floating-point types
聽聽 cout << "max(float):聽聽聽聽聽聽 "
聽聽聽聽聽聽聽 << numeric_limits<float>::max() << endl;
聽聽 cout << "max(double):聽聽聽聽聽 "
聽聽聽聽聽聽聽 << numeric_limits<double>::max() << endl;
聽聽 cout << "max(long double): "
聽聽聽聽聽聽聽 << numeric_limits<long double>::max() << endl;
聽聽 cout << endl;
聽聽 // print whether char is signed
聽聽 cout << "is_signed(char): "
聽聽聽聽聽聽聽 << numeric_limits<char>::is_signed << endl;
聽聽 cout << endl;
聽聽 // print whether numeric limits for type string exist
聽聽 cout << "is_specialized(string): "
聽聽聽聽聽聽聽 << numeric_limits<string>::is_specialized << endl;
}
]]>
private: int i;
public: base(int x){i=x;}
};
class derived: public base{
private: int i;
public: derived(int x, int y) {i=x;}
void printTotal() {int total = i+base::i;}
};
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 necessary).
5.Name three sort algorithms you are familiar with. Write out the correct
order by the average time complexity.
6.Write code to sort a duplex direction linklist. The node T has overridden
the comparision operators.
7.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 eliminate all these dependencies?
]]>