又一些比试题

1.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态?

答：是的。

2.输入一个字符串，将其逆序后输出。（使用C++，不建议用伪码）

int main()
{
  int i_Count = 0;
  char *pch;
  cin>>pch;
  char *p_Char = pch;
  while(*p_Char != '/0')
     {
         p_Char++;
         i_Count++;
     }
  while(i_Count--)
  {
     cout<<*p_Char;
  }
  return 0;
}

3.请简单描述Windows内存管理的方法。

 不会

4.
#include "stdafx.h"
#define SQR(X) X*X

int main(int argc, char* argv[])
{
 int a = 10;
 int k = 2;
 int m = 1;

 a /= SQR(k+m)/SQR(k+m);
 printf("%d/n",a);

 return 0;
}

  不会

5.
const 符号常量；
(1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别；

答:(1) 是所指的内容不能改变
　　(2) 是指针不能改变
　　　(3) 是两者都不能改变

6.下面是C语言中两种if语句判断方式。请问哪种写法更好？为什么？
 int n;
 if (n == 10) // 第一种判断方式
 if (10 == n) // 第二种判断方式

答：第二种好．可以防止像if(10 = n)这样的错误出现

7.下面的代码有什么问题？
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);  // 分配1K的空间
 if (NULL == p)
  return;
 ...
 p = realloc(p, 2048); // 空间不够，重新分配到2K
 if (NULL == p)
  return;
 ...
}
p = malloc(1024)应该写成 p = (char *)malloc(1024)
没有释放动态申请的空间，会造成内存泄漏．

8.下面的代码有什么问题？并请给出正确的写法。
void DoSomeThing(char* p)
{
 char str[16];
 int n;
 assert(NULL != p);
 sscanf(p, "%s%d", str, n);
 if (0 == strcmp(str, "something"))
 {
  ...
 }
}

1. 下面这段代码的输出是多少(在32位机上).

    char *p;   // 4

    char *q[20];   // 80

    char *m[20][20];  // 1600

    int (*n)[10];   // 4

    struct MyStruct

{

char dda;

double dda1;

int type ;

}；
MyStruct k;   // 24

 printf("%d %d %d %d",sizeof(p),sizeof(q),sizeof(m),sizeof(n),sizeof(k));

2.

(1)

char a[2][2][3]={{{1,6,3},{5,4,15}},{{3,5,33},{23,12,7}} };
for(int i=0;i<12;i++)
printf("%d ",___*(**a+i)____);

在空格处填上合适的语句，顺序打印出a中的数字

(2)

char **p, a[16][8]; 

问：p=a是否会导致程序在以后出现问题？为什么？

编译就通不过，p是一个指针的指针，而a是一个2维数组的首地址。
但是*p = a也是错误的。

3.用递归方式,非递归方式写函数将一个字符串反转.

   函数原型如下:char *reverse(char *str);

#include <stdio.h>

/*=======================================================
函 数 名： reverse()
参    数： str
功能描述： 将一个字符串翻转
返 回 值： const char*
抛出异常： 无
作    者： 刘基伟　2007/4/21
=======================================================*/

const char *reverse(char *str);

int main()
 {
  const char *pch;       // 用于取得函数的返回值，来输出翻转后的结果
     char chArray[] = " Hello World ! ";   // 存储一个将要翻转的字符串
  pch = reverse(chArray);     // 将字符串chArray翻转
  printf("%s/n",pch);         // 打印字符串chArray
  return 0;
 }

const char *reverse(char *str)
 {
  if(str == NULL)
   return NULL;
  int  nCount = 0;           // 用来统计字符串的大小
  int  nCount_div;           // 将字符串的大小折半
  const char *pRemark_begin;       // 标记字符串的首地址
  char chTemp;               // 用于交换字符串的临时变量
  char *pString_begin;       // 存储交换的头指针
  char *pString_end;         // 存储交换的尾指针

  pString_begin = str;
  pRemark_begin = str;

  while(*str != '/0')        // 寻找字符串的结尾
  {
   str++;
   nCount++;
  }
  pString_end = --str;       // 退回一个才是字符串的末尾
  nCount_div = nCount/2;

  while(nCount_div>0)        // 将字符串翻转
  {
   chTemp = *pString_begin;
   *pString_begin = *pString_end;
   *pString_end = chTemp;
   pString_begin++;
   pString_end--;
   nCount_div--;
  }
  return pRemark_begin;
 }
1 读程序段，回答问题
int main(int argc,char *argv[])
{
int c=9,d=0;
c=c++%5;
d=c;
printf("d=%d/n",d);
return 0;
}
a) 写出程序输出
   输出是5，9%5=4 4+1=5
b) 在一个可移植的系统中这种表达式是否存在风险？why?
    存在风险，因为在不同编译器，它的自加的实现可能不一样的。
如果这里先C++完，在对5求余，那结果将是2

#include "stdio.h"
int a=0;
int b;
static char c;
int main(int argc,char *argv[])
{
char d=4;
static short e;

a++;
b=100;
c=(char)++a;
e=(++d)++;
printf("a=%d, b=%d, c=%d, d= %d, e=%d",a,b,c,d,e);
return 0;
}
a) 写出程序输出
   a=2, b=100, c=2, d=6, e=5
b) 编译器如果安排各个变量(a,b,c,d)在内存中的布局(eg. stack,heap,data section,bss section),最好用图形方式描述。
   a,b,c,e存储在静态区，d存储在栈里

2 中断是嵌入式系统中重要的组成部分，这导致了许多编译开发商提供一种扩展：让标准C支持中断，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR),请评论以下这段代码。
__interrupt double compute_area(double radius)
{
double area = PI * radius *radius;
printf("nArea = %f", area);
return area;
}
在执行printf函数的，area执行了西沟，返回一个幽灵内存

3 C/C++基础知识问题
a) 关键字volatile在编译时有什么含义?并给出三个不同使用场景的例子(可以伪代码或者文字描述)。
   防止隐式的修改
b) C语言中static关键字的具体作用有哪些 ?
   1.记忆功能
   2.数据共享
   3.本地限定
c) 请问下面三种变量声明有何区别?请给出具体含义
1.int const *p;
2.int* const p;
3.int const* const p;
 
   1是指向常量的指针，不可修改指针所指向的内容，但是可以改变指针的指向
   2是常指针，指向一块固定的内存，不可以更改，但是可以修改所指向的内容
   3这里，既不可以改变指针的指向，也不可以修改指针所指向的内容