- 如下是我们查找数组中某个元素的一种通常做法
const int *Find(const int *array, int length, int x)
{
const int *p = array;
for (size_t i = 0; i < length; i++)
{
if (*p == x)
{
return p;
}
p++;
}
return 0;
}
在这种方法下，我们必须保证数组为int型，知道数组的长度，甚至还要确定整的存在这样一个数组。请你利用template重写此方法来消除所有这些缺陷。
参考：
template<typename T,int n>
const T* find(const T* arr, T x)
{
const T *p = arr;
for (size_t i = 0; i < n; i++)
{
if (*p == x)
{
return p;
}
p++;
}
return 0;
}
其中怎样保证一个数组存在还是没有十分理解，这样的解法只是根据自己的理解所写，望明白的博友指点，不胜感激。
- 假设有如下类
class erp
{
HR* m_hr;
FI* m_fi;
public:
erp()
{
m_hr = new HR();
m_fi = new FI();
}
~erp()
{
}
};
如果new FI()构造器失败，如何检测这个问题并释放已经分配给m_hr的资源？
参考：
使用标准程序库中提供的auto_ptr； auto_ptr是个“类指针（pointer_like）对象”，也就是所谓的“智能指针”，它的析构函数会自动对所指向的对象调用delete，
事实上，以对象管理资源的思想正是C++所倡导的，Effective C++中告诫我们：取得资源的时候正是初始化的时候，即Resource Acquisition Is Initialization
class A
{
HR* m_hr;
FI* f_hr;
public:
A()
{
auto_ptr<HR> a_mhr(new HR());
auto_ptr<FI> a_fhr(new FI());
m_hr = a_mhr.release();
f_hr = a_fhr.release();
f_hr = new FI();
}
~A()
{
}
};
- 有如下类
#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; }
};
void main(){
Base b;
Derived d;
Base* pb = new Derived;
cout << sizeof(Base) << endl; //第一步
cout << sizeof(Derived); //第二步
pb->f(1.0); //第三步
pb->g(); //第四步
}
请问程序的输出结果是多少？
参考：
第一步，第二步中Base，Derived都是类，都是引用类型，所以相当于一个指针的大小，所以是4位的
第三步由于f中的参数是1.0，而Derived中f的参数是complex<double>类型，不等同与double，也就是f并没有覆盖掉父类Base中的f,其实他们就是两个完全不同的函数，只是名字相同而已。所以执行符合要求的父类Base中的f();
第四步由于g是虚函数，而虚函数为动态绑定的，所以执行D::g(), 但因为在Derived中重新定义了继承而来的缺省参数值，而缺省参数值是静态绑定的，所以i的值获取的是Base中g()的缺省值。
要记住，经验告诉我们，永远不要重新定义继承而来的缺省值。
程序执行结果如图：
- 两个人轮流拿10个硬币，每次可拿1，2，4个，拿到最后一个的为输，问有无必胜条
件？
参考：
后拿的人每次只要拿到三的倍数即可。
a. 拿到最后一个的人输，所以自己想法设法让对方给自己留下2,3,5，这样自己就能一招制胜；
b. 基于a，自己拿完后，只能给对方留下1,4,6,7,8,9
c. 如果给对方留下6，对方拿2给自己留4，与b矛盾；如果给对方留8，对方拿4给自己留4也与b矛盾；如果给对方留9，那么对方拿2给自己留7也与b矛盾。
基于abc，理论上讲，先手必输。
- 列举C++中四种强制类型转换，并说明区别？
static_cast： 用来强制进行隐式转换，可以实现C++中内置基本数据类型之间的相互转换
但不能将const转换为non-const；
const_cast: 通常被用来将对象的常量性移除，四个运算符中只有它能进行这样的操作；
dynamic_cast： 用于“安全向下转型”，也就是用来决定某对象是否归属继承体系中的某个类型。
其他三种都是编译时完成的，dynamic_cast是运行时处理的，运行时要进行类型检查。被转换的基类中一定要有virtual函数。
reinterpret_cast: 执行低级转型。
- 给出如下代码的输出结果：
#include <iostream>
using namespace std;
#define DBL(x) x+x
int main()
{
int a = 3;
int b = 4;
int c = DBL(a)*DBL(b);
cout << c << endl;
return 0;
}
答案：
19
执行结果为3+3*4+4=19