2014年中兴笔试试题

#include <iostream>

using namespace std;

int fun (int n)
{
    if (n < 2) {
        return 1;
    } else {
        return n * fun(n - 1);
    }
}

int main()
{
	int i;
	cin >> i;
	cout << fun(i) <<endl;
	return 0;
}

#include <iostream>

using namespace std;

struct Node {
	int data;
	Node *next;
};

Node *reverse (Node *head)
{
	Node *p = head,*q;
	q = new Node;
	head = NULL;
	while (p)
	{
		q = p->next;
		p->next = head;
		head = p;
		p = q;
	}
	return head;

}

int main()
{
	Node *head,*p,*tail;
	int data;
	head = NULL; tail = NULL;
	while ( scanf("%d",&data)&& data != 0)
	{
		p = new Node;
		p->data = data;
		p->next = NULL;
		if(head == NULL)
			head = p;
		else
			tail->next = p;
		tail = p;
	}
	Node *s = reverse(head);
	for (p = s;p;p=p->next)
		cout << p->data <<" ";
	return 0;
}

#include <stdio.h>
#include <stdlib.h>

void main()
{
	char *si,*so;
	si =malloc(10*sizeof(char));
	scanf("%s",si);
	so =malloc(10*sizeof(char));
	if(!so)
	{
		return;
	}
	while(*si)
	{
		*so = *si;
		so++;
		*so =' ';
		si++;
		so++;
	}
	*so='\0';
	printf("%s\n",so);
	return;
}

错误点：因为 malloc返回的类型是void*，所以将其赋值给str时要强制转换成 char*类型的，即：str = (char*)malloc(10*sizeof(char))，其中10是要分配的总数，而sizeof(char)是所分配类型的大小(应该是这样写，由于char的大小为1，所以不加的结果也一样，如果是其它类型的最好加上)；因为你在整个过程中移动了指针so就会导致so指向的就不是你一开始申请的一段空间的首地址了，所以你最后输出不了任何字符。

正确代码：

#include <stdio.h>
#include <stdlib.h>

void main()
{
	char *si,*so;
	si =(char *)malloc(10*sizeof(char));
	scanf("%s",si);
	so =(char *)malloc(10*sizeof(char));
	if(!so)
	{
		return;
	}
	char *temp=so;
	while(*si)
	{
		*so = *si;
		so++;
		*so =' ';
		si++;
		so++;
	}
	*so='\0';
	printf("%s\n",temp);
	return;
}

有if语句为什么还存在switch语句？

如果纯粹比较数字或字符，建议使用switch，因为它只会在一开始的switch括号中取出变量值一次，然后将这个值与下面所设定的case比较，但如果使用if，每次遇到条件式时，都要取出变量值，效率的差异就在这儿。当然并不是使用if就不好，遇到复合条件时，switch就帮不上忙了，由于无法在switch中组合复杂的条件语句，这时就得使用if了。简单地说，if与switch两者可以搭配着灵活使用。

详细解释参考：http://blog.csdn.net/hackbuteer1/article/details/7460019

#include<iostream>
using namespace std;

class Singleton
{
public:
    static Singleton * GetInstance()//通过静态公有函数获得该类的实例对象
    {
        if(m_pInstance==NULL)
        m_pInstance=new Singleton();
        return m_pInstance;
    }

private:
    Singleton(){}//构造函数私有化的目的是为了防止从别处实例化该类对象
    static Singleton * m_pInstance;
    class Garbo//删除Singleton实例的对象
    {
    public:
        ~Garbo()
        {
            if(Singleton::m_pInstance)
            {
                delete Singleton::m_pInstance;
            }
        }
    };
    static Garbo gb;//在程序结束时，系统会调用它的析构函数
};
Singleton * Singleton::m_pInstance=NULL;//初始化静态数据成员

int main()
{
    Singleton *sl=Singleton::GetInstance();
    return 0;
}

如果定义一个派生类的对象，则通过对象名只能访问在派生类中呈现为public访问属性的成员，因此C不对。

答案是后者更好
1没有包含头文件，编译更快
2没有包含头文件，就没有文件依赖，头文件变动也无须重新编译源文件
3没有包含头文件，就不会出现重复包含，循环包含互相依赖等问题。