c/c++ 经典笔试

1、

编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

class String {  　public:  　　String(const char *str = NULL); // 普通构造函数  　　String(const String &other); // 拷贝构造函数  　　~ String(void); // 析构函数  　　String & operate =(const String &other); // 赋值函数  　private:  　　char *m_data; // 用于保存字符串  };

解答：

 

解答：    //普通构造函数 String::String(const char *str)  { 　if(str==NULL)  　{ 　　m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空 　　//加分点：对m_data加NULL 判断 　　*m_data = '\0';  　}  　else 　{ 　　int length = strlen(str);  　　m_data = new char[length+1]; // 若能加 NULL 判断则更好  　　strcpy(m_data, str);  　} } // String的析构函数 String::~String(void)  { 　delete [] m_data; // 或delete m_data; } //拷贝构造函数 String::String(const String &other) 　　　// 得分点：输入参数为const型 {  　int length = strlen(other.m_data);  　m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断 　strcpy(m_data, other.m_data);  } //赋值函数 String & String::operate =(const String &other) // 得分点：输入参数为const型 {  　if(this == &other) 　　//得分点：检查自赋值 　　return *this;  　delete [] m_data; 　　　　//得分点：释放原有的内存资源 　int length = strlen( other.m_data );  　m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断 　strcpy( m_data, other.m_data );  　return *this; 　　　　　　　　//得分点：返回本对象的引用 }

2、

请说出static和const关键字尽可能多的作用

解答：

static关键字至少有下列n个作用：

(1) 函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
(2) 在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
(3) 在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
(4) 在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
(5) 在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

const关键字至少有下列n个作用：

(1) 欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了(2) 对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
(3) 在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
(4) 对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
(5) 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：

const classA operator*(const classA& a1,const classA& a2);

operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：

classA a, b, c;
(a * b) = c; // 对a*b的结果赋值

操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。

剖析：

  小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。

3、

请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1

解答：

int checkCPU() { 　{ 　　union w 　　{  　　　int a; 　　　char b; 　　} c; 　　c.a = 1; 　　return (c.b == 1);//小端c.b=1 　} }

剖析：

　 　嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方 式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little- endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：

内存地址 存放内容 
0x4000 0x34 
0x4001 0x12

　　而在Big-endian模式CPU内存中的存放方式则为：

内存地址 存放内容 
0x4000 0x12 
0x4001 0x34

4、

求函数返回值，输入x=9999; 

int func （ x ）  {  int countx = 0;  while ( x )  {  countx ++;  x = x&(x-1);  }  return countx;  }

结果呢？ 
知道了这是统计9999的二进制数值中有多少个1的函数，且有 
9999＝9×1024＋512＋256＋15 

9×1024中含有1的个数为2； 
512中含有1的个数为1； 
256中含有1的个数为1； 
15中含有1的个数为4； 
故共有1的个数为8，结果为8。 
1000 - 1 = 0111，正好是原数取反。这就是原理。 
用这种方法来求1的个数是很效率很高的。 
不必去一个一个地移位。循环次数最少。 

5、分析下面的程序【位对齐问题】

struct s1  {  int i: 8;  int j: 4;  int a: 3;  double b;  };  struct s2  {  int i: 8;  int j: 4;  double b;  int a:3;  };  printf("sizeof(s1)= %d\n", sizeof(s1));  printf("sizeof(s2)= %d\n", sizeof(s2));  result: 16, 24  第一个struct s1  {  int i: 8;  int j: 4;  int a: 3;  double b;  };

理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，然后是a， 要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8 字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。 
1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：    
struct bs   
{   
unsigned a:4   
unsigned :0 /*空域*/   
unsigned b:4 /*从下一单元开始存放*/   
unsigned c:4   
}   
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。 
2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位
3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：  
struct k   
{   
int a:1   
int :2 /*该2位不能使用*/   
int b:3   
int c:2   
};   
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。 

　　 2. 拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗？

　　String a(“hello”);

　　String b(“world”);

　　String c = a; // 调用了拷贝构造函数，最好写成 c(a);

　　c = b; // 调用了赋值函数

　　本例中第三个语句的风格较差，宜改写成String c(a) 以区别于第四个语句。

　　类String的拷贝构造函数与赋值函数

　　// 拷贝构造函数

　　String::String(const String &other)

　　{

　　// 允许操作other的私有成员m_data

　　int length = strlen(other.m_data);

　　m_data = new char[length+1];

　　strcpy(m_data, other.m_data);

　　}

　　// 赋值函数

　　String & String::operator =(const String &other)

　　{

　　// (1) 检查自赋值

　　if(this == &other)

　　return *this;

　　// (2) 释放原有的内存资源

　　delete [] m_data;

　　// (3)分配新的内存资源，并复制内容

　　int length = strlen(other.m_data);

　　m_data = new char[length+1];

　　strcpy(m_data, other.m_data);

　　// (4)返回本对象的引用

　　return *this;

　　}

　　类String拷贝构造函数与普通构造函数的区别是：在函数入口处无需与NULL进行比较，这是因为“引用”不可能是NULL，而“ 指针 ”可以为NULL。

　　类String的赋值函数比 构造函数 复杂得多，分四步实现：

　　（1）第一步，检查自赋值。你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自 赋值语句 ！的确不会。但是间接的自赋值仍有可能出现，例如

　　// 内容自赋值

　　b = a;

　　…

　　c = b;

　　…

　　a = c;

　　// 地址自赋值

　　b = &a;

　　…

　　a = *b;

　　也许有人会说：“即使出现自赋值，我也可以不理睬，大不了化点时间让对象复制自己而已，反正不会出错！”

　　他真的说错了。看看第二步的delete，自杀后还能复制自己吗？所以，如果发现自赋值，应该马上终止函数。注意不要将检查自赋值的if语句

　　if(this == &other)

　　错写成为

　　if( *this == other)

　　（2）第二步，用delete释放原有的内存资源。如果现在不释放，以后就没机会了，将造成内存泄露。

　　（3）第三步，分配新的内存资源，并复制字符串。注意函数strlen返回的是有效字符串长度，不包含结束符‘\0’。函数strcpy则连‘\0’一起复制。

　　（4）第四步，返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。那么能否写成return other 呢？效果不是一样吗？

　　不可以！因为我们不知道参数other的 生命期 。有可能other是个临时对象，在赋值结束后它马上消失，那么return other返回的将是垃圾。

　　 偷懒的办法处理拷贝构造函数与赋值函数

　　如果我们实在不想编写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，怎么办？

　　偷懒的办法是：只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。

　　例如：

　　class A

　　{ …

　　private:

　　A(const A &a); // 私有的拷贝构造函数

　　A & operate =(const A &a); // 私有的赋值函数

　　};

　　如果有人试图编写如下程序：

　　A b(a); // 调用了私有的拷贝构造函数

　　b = a; // 调用了私有的赋值函数

　　编译器将指出错误，因为外界不可以操作A的私有函数。

　　注意：以上例子在vc中可能编译不过，因关键字不是operate ，而是operator

　　 3.在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值.