一组c++题

这是论坛上的贴的一组题目,思考了一下,写了下来.

1.写出下面程序的输出

class abc;
void del(abc *pobj){
 delete pobj;
}

class abc{
public:
 abc(){
  printf("abc/r/n");
 }
 ~abc(){
  printf("~abc/r/n");
 }
};

int main()
{
 abc *pobj = new abc;
 del(pobj);
}

 输出: abc

解释:对del函数而言,class abc的具体实现是未知的;对一个未知类型的指针掉用全局delete函数,结果未定义.

自然,他不会调用到abc的稀够函数.可以联系一下,在我们的有些工程里,为了减少模块依赖性,在头文件中只前导

声明一下类,而在.cpp文件中包含改类的.h文件,这样.cpp文件中实现函数还是知道改类的类型的.

2.写出下面程序的输出

void* operator new(size_t size)
{
 printf("malloc %u/r/n", size);
 return malloc(size);
}
void operator delete(void *memblock){
 printf("free/r/n");
 return free(memblock);
}

class abc{
public:
 abc(){
  printf("abc/r/n");
  throw int();
 }
 ~abc(){
  printf("~abc/r/n");
 }
};

int main(){
 try{
  new abc;
 }catch(int& i){
  printf("%d/r/n", i);
 }
 return 0;
}

 输出: malloc 1
           abc
           free
           0

解释:  重载了new 和 delete, 而当构造函数中有异常抛出,会释放已分配空间.此时对象没有构建出来,自然不会调用稀构函数的了.具体参见 《More Effective C++》条款10: 在构造函数中防止资源泄漏. 类的大小包括nostatic data member和virtual prt( 如果有的话)，如果是零的话,编译器会分配一个char空间.所以 size 是1;

3.写出下面程序的输出

template <typename T>
class abc{
public:
 abc(){
  printf("primary/r/n");
 }
};

template<>
abc<int>::abc(){
 printf("member spec/r/n");
};

template<typename T, typename P>
class abc<T (*)(P)>{
public:
 abc(){
  printf("partial spec/r/n");
 }
};

int main()
{
 abc<void* (*)(int)> f_abc;
 abc<int> i_abc;
}

输出: partial spec

        member spec

        T (*)(P) 表示一个返回值为T，参数为P的一个函数模版，所以f_abc是class abc<T (*)(P)> 的一个实例。template<>是模版特例化标志。template<> abc<int>::abc()特例化了 template<class T> abc 的构造函数。所以当模版是int所产生出来的实例都是调用特化的，专门的template<> abc<int>::abc(){...}；

4.下面的代码能否通过编译？为什么

class a{
public:
 virtual ~a(){
 }
private:
 void operator delete(void *p);
};

int main()
{
 a _1;
}

编译不过, operator delete函数未实现.

如果一个类有virtual 稀构函数会,而且有自定义的 operator delete函数,则一定要给出实现.(稀构函数不是virtual 没关系).

但并没有调用 operator delete函数.可能是编译器需要他,不知在背后偷偷的干了什么.