C题目

1、用预处理指令#define声明一个常数，用以表明一年中有多少秒（忽略闰年的问题）

解析：1.#define语法的基本知识（例如，不能以分号结束，括号的使用等）

        2.要懂得预处理器将为你计算常数表达式的值，因此，写出你是如何计算一年中有多少秒而不是计算出实际的值，会更好意义。

        3.意识到这个表达式将使一个16位机的整型数溢出，因此要用到长整形符号L，告诉编译器这个常数是长整型数。

   如果表达式中用到UL（表示无符号长整型），那么你就有了一个好的第一印象了，记住，第一印象很重要。

答案：

?

1	#define SECONDS_PER_YEAR(60*60*24*365)UL

 

2、写一个“标准”的宏MIN，这个宏输入两个参数并返回较少的一个

解析：1.标识#define在宏中应用的基本知识，这是很重要的，因为知道嵌入操作符变为标准C的一部分，宏都是方便地产生嵌入代码的唯一方法。对伊嵌入

           式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。

        2.三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。

        3.懂得在宏中小心的把参数用括号括起来。

答案：

?

1	#define MIN(A,B) ((A) <= (B) ? (A) : (B))

 

3、const有什么用途？请至少说明两种？

解析：在C程序中，const的用法主要有定义常量、修饰函数参数、修饰函数返回值。在C++程序中，它还可以修饰函数的定义体，定义类中某个成员函数为恒态函数，即不改变类中的数据成员。

答案：

（1）可以定义const常量。（2）const可以修饰函数的参数和返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

 

4、const与#define相比有什么不同？

答案：

C++语言可以用const定义常量，也可以用#define定义常量，但是前者比后者有更多的有点：

（1）const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行 类型安全检查，而对后者只是进行字符替换，没有类型安全检查，并且在字符替换中可能产生意料不到的错误（边际效应）。

（2）有些集成话的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

 

5、下面代码输出结果是什么？

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

#include<iostream> using  namespace  std;   struct {      short  a1;      short  a2;      short  a3; }A;   struct {      long  a1;      short  a2; }B;   int  main () {      char * ss1 = "0123456789" ;      char  ss2[] = "0123456789" ;      char  ss3[100] = "0123456789" ;      int  ss4[100];      char  q1[] = "abc" ;      char  q2[] = "a\n" ;      char * q3 = "a\n" ;      char  *str1 = ( char  *) malloc (100);      void  *str2 = ( void  *) malloc (100);        cout<< "sizeof(ss1):" << sizeof (ss1)<<endl;      cout<< "sizeof(ss2):" << sizeof (ss2)<<endl;      cout<< "sizeof(ss3):" << sizeof (ss3)<<endl;      cout<< "sizeof(ss4):" << sizeof (ss4)<<endl;      cout<< "sizeof(q1):" << sizeof (q1)<<endl;      cout<< "sizeof(q2):" << sizeof (q2)<<endl;      cout<< "sizeof(q3):" << sizeof (q3)<<endl;      cout<< "sizeof(A):" << sizeof (A)<<endl;      cout<< "sizeof(B):" << sizeof (B)<<endl;      cout<< "sizeof(str1):" << sizeof (str1)<<endl;      cout<< "sizeof(str2):" << sizeof (str2)<<endl;        return  0; }

解析：ss1是一个字符指针，指针的大小是一个定值，就是4字节，所以sizeof(ss1)是4字节

ss2是一个字符数组，这个数组最初未定大小，由具体填充值来定。填充值是“0123456789 ”。1个字符所占空间是1字节，10个就是10字节，再加上隐含的“\0”，所以一共是11字节。

ss3也是一个字符数组，这个数组开始预分配100，所以它的大小一共是100字节。

ss4也是一个字符数组，这个数组开始预分配100，但是每个整型变量所占用空间是4，所以它的大小一共是400字节。

q1与ss2类似，所以是4字节。

q2里面有一个“\n”，“\n”算做一位，所以它的空间大小是3字节。

q3是一个字符指针，指针的大小是一个定值，就是4，所以sizeof(q3)是4字节。

A和B是两个结构体，在默认情况下，为了方便对结构体内元素的访问和管理，当结构体内的元素的长度都小于处理器的位数的时候，便以结构体里面最长的数据元素为对齐单位，也就是说，结构体的长度一定是最长的数据元素的整数倍。如果结构体内存在长度大于处理器位数的元素，那么就以处理器的位数为对齐单位，但是结构体内类型相同的连续元素将在连续的空间内，和数组一样。

结构体A中有3个short类型变量，各自以2个字节对齐，所以sizeof(A)是为6字节。结构体B中a1以4字节对齐，a2以2字节对齐，则结构体大小为6字节，但是结构体的长度一定是最长数据元素的整数倍，显然6不是4的整数倍数，补空字节，增到8字节，符合所以条件。故sizeof(B)为8字节。

str1和str2都是字符指针，都是4字节。

答案：

sizeof(ss1):  4

sizeof(ss2):  11 
sizeof(ss3):  100 
sizeof(ss4):  400

sizeof(q1):   4

sizeof(q2):  3 
sizeof(q3):  4

sizeof(A):  6

sizeof(B):  8

sizeof(str1):  4 
sizeof(str2):  4

 

6、以下代码为32位机器编译，数据是以4字节为单位，这两个类型的输出结果为什么不同？

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class  B { private :      bool  m_bTemp1;      int  m_nTemp;      bool  m_bTemp2; };   class  C { private :      int  m_nTemp;      bool  m_bTemp1;      bool  m_bTemp2; };   cout << sizeof (B) << endl; cout << sizeof (C) << endl;

 

解析：编译器会对结构体进行对齐处理，根据对齐原则。

类型B情况如下：

| bool |-----|----|----|

|-----------int---------|

| bool |-----|----|----|

 

类型C情况如下：

|-----------int-----------|

| bool | bool |----|----|

 

答案：

B类输出12字节，C类输出8字节。

 

7、说明sizeof和strlen之间的区别

解析：

第1个例子：

char *a="0123456789";

sizeof(a)结果为4，a是指向字符串常量的字符指针。

sizeof(*a)结果是1，*a是第一个字符。

strlen(a)结果是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第2个例子：

char a[100]="0123456789";

sizeof(a)结果为100，a表示在内存中预分配的大小。

strlen(a)结果还是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第3个例子：

char a[]="0123456789";

sizeof(a)结果为11，a是数组计算到“\0”位置，因此是（10+1）。

strlen(a)结果还是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第4个例子：

int  a[100]="0123456789";

sizeof(a)结果为400，a表示在内存中预分配的大小,100*4。

strlen(a)错误，strlen的参数只能是char*，且必须是以“\0”结尾的。

答案：

（1）sizeof操作符的结果类型是size_t，它在头文件中的typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。

（2）sizeof是运算符，strlen是函数。

（3）sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以“\0”结尾的。sizeof还可以用函数做参数，结果与函数返回值的类型一致。

（4）数组做sizeof的参数不退化，传递给strlen就退化为指针。

（5）strlen的结果要运行时才能计算出来，用来计算字符串的长度，而不是类型占内存的大小。

（6）sizeof计算结构变量的大小就必须讨论数据对齐问题（C++处理数据时经常把结构变量中的成员的大小按照4或8的倍数计算）。

（7）sizeof操作符不能用于函数类型、不完全类型或位字段。不完全类型指具有未知存储大小数据的数据类型，如：未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。

 

8、以下代码的输出结果是多少？

?

1 2 3 4 5

char  var[10] int  test ( char  var[]) {      return  sizeof (var); }

 

解析：数组作为参数传递，传递的是一个首地址，等价于*var，已退化成一个指针了，所以大小是4。

答案：

4

 

9、一个空类占多少空间？多重继承的空类呢？

解析：我们用程序来实现一个空类和多重继承的空类，看看它们的大小是多少。代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

#include<iostream> using  namespace  std;   class  A1 { };   class  A2 { };   class  B : public  A1 { };   class  C : public  virtual  B { };   class  D : public  A1, public  A2 { };   int  main () {      cout << "sizeof(A1):"  << sizeof (A1) << endl;      cout << "sizeof(B):"  << sizeof (B) << endl;      cout << "sizeof(C):"  << sizeof (C) << endl;      cout << "sizeof(D):"  << sizeof (D) << endl;        return  0; }

以上答案分别是1，1，4，1。这说明空类所占空间为 1，单一继承的空类空间也是 1，多重继承的空类空间还是 1，但是虚继承涉及虚表（虚指针），所以大小为 4。

答案：

一个空类占空间为 1 ，多重继承的空类所占空间还是 1，但虚继承的为 4。