莫名科技面试题

1. int   i = 3, j = 4;
   i++; ++j;
   printf("%d  %d",++i ,j++);
输出结果 
答案
  5   5

2 写一个“标准”宏MIN，这个宏输入2个参数返回较小的一个
答案
（谢谢  theanswerzju  指出之前形参未写）
#define MIN(a,b)  ((a)>(b))?(b):(a)

3.简述const的用途

答案


4.class和struct的区别
答案
唯一的区别就是：
 访问权限不一样  
  struct    默认情况下数据是公有的(public)；  
  class     默认情况下数据是私有的(private)；

（谢谢  theanswerzju  指出）
补充，还有 继承权限不一样
struct    默认情况下数据是公有继承的(public)；  
  class     默认情况下数据是私有继承的(private)；

再补充：
struct不支持泛型
还有如果你不使用虚函数 不需要构造 析构等等，使用struct要比class高效
编译器会优化



5.看代码，写输出结果
#include
#include "stdafx.h"
#include
using namespace std;

struct 
{
 short a1;
 short a2;
 short a3;
}A;

struct
{
 long a1;
 short a2;
}B;
int _tmain(int argc, _TCHAR* argv[])
{
 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< cout< cout< cout< cout< cout< cout< cout< cout< cout< cout< getchar();
 return 0;
}

结果 4  11  100  400 4 3 4 6 8 4 4

void foo(void)
{
   unsigned int a = 6;
   int b = -20;
  (a+b>6)?puts(">6"):puts("<=6");
}

结果   >6

 做错了，这题
b会转换为 unsigned int ，那么最高位是1，所以b的数字就很大了，肯定大于6


6.#define和typede的区别，你更喜欢哪种？Why?
答案:
1)   #define是预处理指令，在编译预处理时进行简单的替换，不作正确性检查，不关含义是否正确照样带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。例如：  
    #define   PI   3.1415926  
    程序中的：area=PI*r*r     会替换为3.1415926*r*r  
  如果你把#define语句中的数字9   写成字母g   预处理也照样带入。  
   
  2）typedef是在编译时处理的。它在自己的作用域内给一个已经存在的类型一个别名，但是You   cannot   use   the   typedef   specifier   inside   a   function   definition。  
   
  3）typedef     int   *   int_ptr;  
  与  
            #define   int_ptr   int   *    
    作用都是用int_ptr代表   int   *   ,但是二者不同，正如前面所说   ，#define在预处理   时进行简单的替换，而typedef不是简单替换   ，而是采用如同定义变量的方法那样来声明一种类型。也就是说;  
   
  //refer   to         (xzgyb(老达摩))  
  #define   int_ptr   int   *  
  int_ptr   a,   b;     //相当于int   *     a,   b;   只是简单的宏替换  
   
  typedef   int*   int_ptr;  
  int_ptr   a,   b;     //a,   b   都为指向int的指针,typedef为int*   引入了一个新的助记符  
   
   
  这也说明了为什么下面观点成立  
  //QunKangLi(维护成本与程序员的创造力的平方成正比)  
  typedef   int   *   pint   ;  
  #define   PINT   int   *  
   
  那么：  
  const   pint   p   ;//p不可更改，但p指向的内容可更改  
  const   PINT   p   ;//p可更改，但是p指向的内容不可更改。  
   
  pint是一种指针类型     const   pint   p   就是把指针给锁住了     p不可更改  
  而const   PINT   p       是const   int   *     p     锁的是指针p所指的对象。  
   
  3）也许您已经注意到#define   不是语句     不要在行末加分号，否则     会连分号一块置换。   
   

7.非C++内建型别A和B，在哪几种情况下B能隐式转化为A？

显式转换和隐式转换的区别：
static_cast用于将派生类指针转换成基类指针。发生于编译时刻。
dynamic_cast用于将基类指针转换成派生类指针。发生于运行时刻。

static_cast还可用于：
- 转换不同内建数据类型（char->int，flot->double等）
- 转换整数类型到enum
- 转换空指针为任何其它类型的空指针

reinterpret_cast可用于：
- 转换任何相关或不相关的指针
- 转换指针为整数类型 （反过来也行吗？）
- 转换空指针为任何其它类型的空指针


8.C++中的空类，默认产出哪些类的成员函数？
答案：

class Empty

{

  public:

  Empty(); // 缺省构造函数

  Empty( const Empty& ); // 拷贝构造函数

  ~Empty(); // 析构函数

  Empty& operator=( const Empty& ); // 赋值运算符

  Empty* operator&(); // 取址运算符

  const Empty* operator&() const; // 取址运算符 const

};


10.写一个函数，完成内存之间的拷贝


5. 用变量a给出下面的定义
a) 一个整型数（An integer）
b) 一个指向整型数的指针（A pointer to an integer）
c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）
d) 一个有10个整型数的数组（An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer