C++面试经常涉及的概念1

1.new、delete、malloc、free关系

delete会调用对象的析构函数,和new对应。free只会释放内存，new调用构造函数。malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。

网易面试题：new/delete和malloc/free的区别

new/delete：给定数据类型，new/delete会自动计算内存大小，并进行分配或释放。如果是对类进行操作，new/delete还会自动调用相应的构造函数和析构函数。

malloc/free：没有进行任何数据类型检查，只负责分配和释放给定大小的内存空间。

有些情况下，new/delete和malloc/free都不能满足性能的要求，我们需要自建内存分配来提高效率。比如，如果程序需要动态分配大量很小的对象，我们可以一次分配可以容纳很多小对象的内存，将这些小对象维护在链表中，当程序需要时直接从链表中返回一个。还有一点，new返回指定类型的指针；而malloc返回void*，必须强制类型转化。（确实，我们每次调用malloc，都要强制转换）

有个比较有意思的地方是:int *p=(void*)malloc(1);可以编译并运行。

）

2.与 delete []区别

delete只会调用一次析构函数，而delete[]会调用每一个成员的析构函数。

3.有哪些性质（面向对象特点）

封装，继承和多态。

4.子类析构时要调用父类的析构函数吗？

析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了。定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数

16. C++中的class和struct的区别

从语法上，在C++中（只讨论C++中）。class和struct做类型定义时只有两点区别：
（一）默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；
（二）成员的默认访问权限。class的成员默认是private权限，struct默认是public权限。
除了这两点，class和struct基本就是一个东西。语法上没有任何其它区别。

求下面函数的返回值（微软）

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

假定x = 9999。 答案：8

思路：将x转化为2进制，看含有的1的个数。

5:什么是“引用”？申明和使用“引用”要注意哪些问题？

引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。

6:“引用”与多态的关系？

引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例

a)

＃include <stdio.h>
union
{
int i;
char x[2];
}a;

void main()
{
a.x[0] = 10; //2进制就是0000 1010（0AH）
a.x[1] = 1 ; //2进制就是 0000 0001（01H）
printf("%d",a.i); //结果就是 0000 0001 0000 1010=266
}
答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）

b)

main() 
     { 
          union

{                   /*定义一个联合*/ 
               int i; 
               struct

{             /*在联合中定义一个结构*/ 
                    char first; 
                    char second; 
               }half; 
          }number;

number.i=0x4241;         /*联合成员赋值*/ 
          printf("%c%cn", number.half.first, mumber.half.second); 
          number.half.first='a';   /*联合中结构成员赋值*/ 
          number.half.second='b'; 
          printf("%xn", number.i); 
          getch(); 
     } 
答案： AB   (0x41对应'A',是低位；Ox42对应'B',是高位）

6261 (number.i和number.half共用一块地址空间）

9:多态的作用？

主要是两个：

1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；

2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。

12. 描述内存分配方式以及它们的区别?

1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

（还有一个代码段，c++内存管理方式：

自动内存分配，静态内存分配，动态内存分配）

14：请说出const与#define 相比，有何优点？

答案：

(在定义数组的时候int a[N];N可以用2方式:

#define N 10

或const int N=10;

)

Const作用：定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。（确实如此，const常量有数据类型，而一旦有数据类型之后，编译器就可以进行类型安全检查。）
      2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

15：简述数组与指针的区别？

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。

16.类成员函数的重载、覆盖和隐藏区别？

答案：a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
 c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

17.求出两个数中的较大值

There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.

答案：( ( a + b ) + abs( a - b ) ) / 2 （这个还难想到）

19.如何判断一段程序是由C 编译程序还是由C++编译程序编译的？

答案：
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif

（c++里面的NULL就是以这种方式定义的：

/* Define NULL pointer value */
#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void *)0)
#endif
#endif

20：堆栈溢出一般是由什么原因导致的？

答 、1.没有回收垃圾资源

2.层次太深的递归调用

(比如写：

int factorial(int n)
{
    return n*factorial(n-);
}

递归会一直进行下去，按F5调试报错：stack overflow）。

21：什么函数不能声明为虚函数？

答 、constructor

22.用两个栈实现一个队列的功能？要求给出算法和思路！

答 、设2个栈为A,B, 一开始均为空.

入队:

将新元素push入栈A;

出队:

(1)判断栈B是否为空；

(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；（应该是为空）

(3)将栈B的栈顶元素pop出；

23.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B) ((A) <= (B)？ (A) : (B))

（宏定义后面最外面都要加一个（），

24.交换两个数的宏定义

交换两个参数值的宏定义为：. #define SWAP(a,b) (a)=(a)+(b);(b)=(a)-(b);(a)=(a)-(b);

为什么后面要有一个；因为swap交换是一个语句，前面Min不能有分号，因为一般返回的是一个表达式。

25.用变量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

26：关键字static的作用是什么？

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

（这个区别很重要，在函数外定义的如static int x；

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝。

如我在static.cpp文件内：

 static int all=;

在main.cpp内：

#include<iostream>
using namespace std;

int main()
{
    extern int all;
    cout<<all<<endl;

}

注意：static.cpp和main.cpp在同一个project，我们不需要include，编译运行会提示：

无法解析的外部变量,int all.

当时把static.cpp前面的staitc去掉，改成int all=2;就可以了。

说明static 全局变量只在定义该变量的源文件中有效，在其他文件中不能引用。）

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

27：.下面的代码输出是什么，为什么？

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) puts("> 6") : puts("<= 6");

}

这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是“>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。(确实，有符号数和无符号数在一起会都转成无符号类型）因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6

28：.C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c;

c = a+++b;

因此, 这段代码持行后a = 6, b = 7, c = 12。

（其实这题要搞清楚a++是右值,我们首先去a的值5，然后+b，得C为12，a再自增1，为6）

29：.用递归算法判断数组a[N]是否为一个递增数组。

递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：

bool fun( int a[], int n )

{

if( n= =1 )

return true;

if( n= =2 )

return a[n-1] >= a[n-2];

return fun( a,n-1) && ( a[n-1] >= a[n-2] );

}

（我开始写的是:

没必要判断n==2.

bool isIncreased(int a[],int n)
{
    if(n==)
        return true;
    return a[n-]<=a[n-]?isIncreased(a,n-):false;
}

程序正确).

18.如何打印出当前源文件的文件名以及源文件的当前行号？

答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。

char a[] = "hello world";
       char *p = a;
       cout<< sizeof(a) << endl; // 12 字节,结束符号'/0'也要计算在里面
       cout<< sizeof(p) << endl; // 4 字节
    计算数组和指针的内存容量

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
      void Func(char a[100])
      {
           cout<< sizeof(a) << endl; // 4 字节而不是100 字节
      }

19:分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

分别写出bool int float pointer与0比较 .

BOOL :    if ( !a ) or if(a)
int :     if ( a == 0)
float :             if ( a < 0.00001&& a >-0.00001) （
pointer : if ( a != NULL) or if(a == NULL)

20:引用”与指针的区别是什么？

指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

21.结构与联合有和区别？

(1). 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 
   (2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

22.     析构函数和虚函数的用法和作用

析构函数是在对象生存期结束时自动调用的函数，用来释放在构造函数分配的内存。

虚函数是指被关键字virtual说明的函数，作用是使用C++语言的多态特性

23：  Windows程序的入口是哪里？写出Windows消息机制的流程

Windows程序的入口是WinMain()函数。

Windows应用程序消息处理机制：

A. 操作系统接收应用程序的窗口消息，将消息投递到该应用程序的消息队列中

B. 应用程序在消息循环中调用GetMessage函数从消息队列中取出一条一条的消息，取出消息后，应用程序可以对消息进行一些预处理。

C. 应用程序调用DispatchMessage，将消息回传给操作系统。

D. 系统利用WNDCLASS结构体的lpfnWndProc成员保存的窗口过程函数的指针调用窗口过程，对消息进行处理。

宏与内联函数的区别

内联函数和宏都是在程序出现的地方展开，内联函数不是通过函数调用实现的，是在调用该函数的程序处将它展开（在编译期间完成的）；宏同样是；

不同的是：内联函数可以在编译期间完成诸如类型检测，语句是否正确等编译功能；宏就不具有这样的功能，而且宏展开的时间和内联函数也是不同的（在运行期间展开）

转自：http://blog.csdn.net/shengliz/article/details/5345124