收集的一些C，C++面试题目，可以看看_下面的语句是什么意思?如何声明或定义才使它们更易懂?(10分) int (*foo())(); in-CSDN博客

嵌入式面试试题

一、ANSI C/C++方面的知识

一.1、简答题。下面的题目必须全部答对才给分(20分)：

1、如何在C中初始化一个字符数组。2、如何在C中为一个数组分配空间。 3、如何初始化一个指针数组。

4、如何定义一个有10个元素的整数型指针数组。 5、 s[10]的另外一种表达方式是什么。 6、 GCC3.2.2版本中支持哪几种编程语言。 7、要使用CHAR_BIT需要包含哪个头文件。 8、对(-1.2345)取整是多少？

9、如何让局部变量具有全局生命期。 10、C中的常量字符串应在何时定义？

11、如何在两个.c文件中引用对方的变量。 12、使用malloc之前需要做什么准备工作。 13、realloc函数在使用上要注意什么问题。 14、strtok函数在使用上要注意什么问题。 15、gets函数在使用上要注意什么问题。

16、C语言的词法分析在长度规则方面采用的是什么策略？ 17、a+++++b所表示的是什么意思？有什么问题？ 18、如何定义Bool变量的TRUE和FALSE的值。

19、C语言的const的含义是什么。在定义常量时，为什么推荐使用const，而不是#define。

20、C语言的volatile的含义是什么。使用时会对编译器有什么暗示。一.2、问答题。

1、———————————————————– “匈牙利命名法”有什么优缺点？(2分) 2、———————————————————– 下面x, y, *p的值是多少，有什么问题？(2分) int x, y, z = 2; int *p=&z; x=sizeof*p; y=x

3、———————————————————–

下面的语句是什么意思？如何声明或定义才使它们更易懂？(10分) int (*foo())(); int (*foo())[]; int (*foo[])(); (*(void(*)())0)();

1、解释堆和栈的区别。

2、论述含参数的宏与函数的优缺点。

3、请讲一讲析构函数和虚函数的用法和作用。

4、在C++中有没有纯虚构造函数？

5、在C++的一个类中声明一个静态成员函数有没有用？

6、如何实现一个非阻塞的socket?

7、在c++中纯虚析构函数的作用是什么？请举例说明。

8、局部变量能否和全局变量重名？

9、如何引用一个已经定义过的全局变量？

10、全局变量可不可以定义在可被多个.C文件包含的头文件中？什么？可以，在不同C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有个C

文件中对此变量赋初值，此时连接不会出错。

11、do……while和……

do有什么区别？

12、对于一个频繁使用的短小函数,在语言中应用什么实现在

C++中应用什么实现? c用宏定义，c++用inline

13、是不是一个父类写了一个

virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态?

14、如果用VC开发程序，常见LNK2001错误，错误的原因是什么。

15、你认为为什么数组不支持数组和数组之间的赋值操作？如果支持操作，需要哪些信息？此题考察数组名的意义。

下面这些问题，大概会占面试时间的一半，并且会问很多问题，一不小心学生可能会被问住，兼顾

考察他们的应变能力和心里素质。

13、指针和引用有什么分别；传引用比传指针安全，为什么？如果我使用常量指针难道不行吗？

14、1) 因为引用肯定会指向一个对象，在C++里，引用应被初始化。

2) 不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。

3) 指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变。

4) 指针变量和所指向的变量占用不同的内存，但引用和所引用的变量指向同一个内

总的来说，在以下情况下你应该使用指针，一是你考虑到存在不指向任何对象的可能（在这种情

况下，你能够设置指针为空），

二是你需要能够在不同的时刻指向不同的对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。引用主要是为了实现参数的地址传递，当然，我们可以通过传递指针改变实参指向的变量的内容，但你要明白，那只是程序设计技巧，以前C是不支持引用的，所以C不支持参数的地址传递，因此如果我们想改变实参的值，就只能通过那种技巧来实现，有时候为了改变一个指针的值我们不得不传一个二级指针，很容易搞胡涂。现在有了引用，

我们就不用担心了，是不是使用技巧让编译器去处理吧，我们只要使用引用就实现了地址传递，想

改变谁就传谁。引用既具有指针的效率，又具有变量使用的方便性和直观性．

14、参数传递有几种方式；实现多态参数传递采用什么方式，如果没有使用某种方式原因是什么；

15、构造函数可否是虚函数，为什么？析构函数呢，可否是纯虚的呢？

构造函数不能为虚函数，要构造一个对象，必须清楚地知道要构造什么，否则无法构造一个对象。析构函数可以为纯虚函数。

6、C也可以通过精心封装某些函数功能实现重用，那C++

的类有什么优点吗，难道仅仅是为实现重

1. 以下三条输出语句分别输出什么？[C易]
char str1[]       = "abc";
char str2[]       = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5  = "abc";
const char* str6  = "abc";
cout << boolalpha << ( str1==str2 ) << endl; // 输出什么？
cout << boolalpha << ( str3==str4 ) << endl; // 输出什么？
cout << boolalpha << ( str5==str6 ) << endl; // 输出什么？

文章出自http://www.ad0.cn/
2. 非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A？[C++中等]
答：
a. class B : public A { ……} // B公有继承自A，可以是间接继承的
b. class B { operator A( ); } // B实现了隐式转化为A的转化
c. class A { A( const B& ); } // A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数
d. A& operator= ( const A& ); // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

3. 以下代码中的两个sizeof用法有问题吗？[C易]
void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
    for( size_t i=0; i        if( 'a'<=str[i] && str[i]<='z' )
            str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;

4. 以下代码有什么问题？[C难]
void char2Hex( char c ) // 将字符以16进制表示
{
    char ch = c/0x10 + '0'; if( ch > '9' ) ch += ('A'-'9'-1);
    char cl = c%0x10 + '0'; if( cl > '9' ) cl += ('A'-'9'-1);
    cout << ch << cl << ' ';
}
char str[] = "I love 中国";
for( size_t i=0; i    char2Hex( str[i] );
cout << endl;

5. 以下代码有什么问题？[C++易]
struct Test
{
    Test( int ) {}
    Test() {}
    void fun() {}
};
void main( void )
{
    Test a(1);
    a.fun();
    Test b();
    b.fun();
}

6. 以下代码有什么问题？[C++易]
cout << (true?1:"1") << endl;

7. 以下代码能够编译通过吗，为什么？[C++易]
unsigned int const size1 = 2;
char str1[ size1 ];
unsigned int temp = 0;
cin >> temp;
unsigned int const size2 = temp;
char str2[ size2 ];

8. 以下代码中的输出语句输出0吗，为什么？[C++易]
struct CLS
{
    int m_i;
    CLS( int I ) : m_i(i) {}
    CLS()
    {
        CLS(0);
    }
};
CLS obj;
cout << obj.m_i << endl;

9. C++中的空类，默认产生哪些类成员函数？[C++易]
答：
class Empty
{
public:
    Empty();                          // 缺省构造函数
    Empty( const Empty& );            // 拷贝构造函数
    ~Empty();                         // 析构函数
    Empty& operator=( const Empty& ); // 赋值运算符
    Empty* operator&();               // 取址运算符
    const Empty* operator&() const;   // 取址运算符 const
};

10. 以下两条输出语句分别输出什么？[C++难]
float a = 1.0f;
cout << (int)a << endl;
cout << (int&)a << endl;
cout << boolalpha << ( (int)a == (int&)a ) << endl; // 输出什么？
Float b = 0.0f;
cout << (int)b << endl;
cout << (int&)b << endl;
cout << boolalpha << ( (int)b == (int&)b ) << endl; // 输出什么？

11. 以下反向遍历array数组的方法有什么错误？[STL易]
vector array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 3 );
for( vector::size_type i=array.size()-1; i>=0; --I ) // 反向遍历array数组
{
    cout << array[i] << endl;
}

12. 以下代码有什么问题？[STL易]
typedef vector IntArray;
IntArray array;
array.push_back( 1 );
array.push_back( 2 );
array.push_back( 2 );
array.push_back( 3 );
// 删除array数组中所有的2
for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor )
{
    if( 2 == *itor ) array.erase( itor );
}

13. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]
答：
void* mymemcpy( void *dest, const void *src, size_t count )
{
    char* pdest = static_cast( dest );
    const char* psrc = static_cast( src );
    if( pdest>psrc && pdest    {
        for( size_t i=count-1; i!=-1; --I )
                pdest[i] = psrc[i];
    }
    else
    {
        for( size_t i=0; i            pdest[i] = psrc[i];
    }
    return dest;
}
int main( void )
{
    char str[] = "0123456789";
    mymemcpy( str+1, str+0, 9 );
    cout << str << endl;

    system( "Pause" );
    return 0;
}

本试题仅用于考查C++/C程序员的基本编程技能。内容限于C++/C常用语法，不涉及数据结构、算法以及深奥的语法。考试成绩能反映出考生的编程质量以及对C++/C的理解程度，但不能反映考生的智力和软件开发能力。
笔试时间90分钟。请考生认真答题，切勿轻视。

一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）

提示：这里“零值”可以是0, 0.0 , FALSE或者“空指针”。例如 int 变量 n 与“零值”比较的 if 语句为：

if ( n == 0 )
if ( n != 0 )
以此类推。

请写出 BOOL flag 与“零值”比较的 if 语句：
请写出 float x 与“零值”比较的 if 语句：
请写出 char *p 与“零值”比较的 if 语句：

二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）
char str[] = “Hello” ;
char *p = str ;
int n = 10;
请计算
sizeof (str ) =
sizeof ( p ) =
sizeof ( n ) =
void Func ( char str[100])
{
请计算
sizeof( str ) =
}

void *p = malloc( 100 );
请计算
sizeof ( p ) =

三、简答题（25分）
1、头文件中的 ifndef/define/endif 干什么用？
2、#include 和 #include “filename.h” 有什么区别？
3、const 有什么用途？（请至少说明两种）
4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”声明？
5、请简述以下两个for循环的优缺点
// 第一个
for (i=0; i++;)
{
if (condition)
DoSomething();
else
DoOtherthing();
}
// 第二个

if (condition)
{
for (i=0; i++;)
DoSomething();
}
else
{
for (i=0; i++;)
DoOtherthing();
}

优点：
缺点：
优点：
缺点：

四、有关内存的思考题（20分）
void GetMemory(char *p)
{
p = (char *)malloc(100);
}

void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}

请问运行Test函数会有什么样的结果？

答：
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}

void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}

请问运行Test函数会有什么样的结果？
答：
Void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}

void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}

请问运行Test函数会有什么样的结果？

答：
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}

请问运行Test函数会有什么样的结果？

答：

五、编写strcpy函数（10分）
已知strcpy函数的原型是
char *strcpy(char *strDest, const char *strSrc);
其中strDest是目的字符串，strSrc是源字符串。
（1）不调用C++/C的字符串库函数，请编写函数 strcpy
（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？

六、编写类String的构造函数、析构函数和赋值函数（25分）
已知类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的上述4个函数。

文章出自http://www.ad0.cn/
文章出自网魂工作室http://www.ad0.cn/
附录C ：C++/C试题的答案与评分标准
一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）

请写出 BOOL flag 与“零值”比较的 if 语句。（3分）

标准答案：
if ( flag )
if ( !flag )
如下写法均属不良风格，不得分。

If (flag == TRUE)
if (flag == 1 )
if (flag == FALSE)
if (flag == 0)

请写出 float x 与“零值”比较的 if 语句。（4分）

标准答案示例：

const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)
不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。

如下是错误的写法，不得分。

If (x == 0.0)
if (x != 0.0)

请写出 char *p 与“零值”比较的 if 语句。（3分）

标准答案：

if (p == NULL)
if (p != NULL)
如下写法均属不良风格，不得分。

If (p == 0)
if (p != 0)

if (p)
if (!)

二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）
char str[] = “Hello” ;
char *p = str ;
int n = 10;
请计算
sizeof (str ) = 6 （2分）
sizeof ( p ) = 4 （2分）
sizeof ( n ) = 4 （2分）
void Func ( char str[100])
{
请计算
sizeof( str ) = 4 （2分）
}

void *p = malloc( 100 );
请计算
sizeof ( p ) = 4 （2分）

三、简答题（25分）
1、头文件中的 ifndef/define/endif 干什么用？（5分）
答：防止该头文件被重复引用。

2、#include 和 #include “filename.h” 有什么区别？（5分）

华为的CC++面试题

Q1:请你分别划划OSI的七层网络结构图，和TCP/IP的五层结构图？
: Q2:请你详细的解释一下IP协议的定义，在哪个层上面，主要有什么作用？
: TCP与UDP呢？
: 总得来说前面两道题目还是比较简单的！
: Q3:请问交换机和路由器分别的实现原理是什么？分别在哪个层次上面实
: 现的？
: Q4:请问C++的类和C里面的struct有什么区别？
: Q5:请讲一讲析构函数和虚函数的用法和作用？
: Q6:全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器
: 是怎么知道的？
: Q7:一些寄存器的题目，我忘记了具体实什么题目，主要好像是寻址和内
: 存管理等一些知识，不记得了。
: Q8:8086是多少尉的系统？在数据总线上是怎么实现的？还有一些硬件方
: 面的知识我既不清楚了。

: 一般建议参加华为的研发面试的同学先要准备一下相关的知识，软件的主要
: 是看看C和数据结构方面的，硬件模电，数电和微机原理

两道c面试题

1、一个学生的信息是：姓名，学号，性别，年龄等信息，用一个链表，把这些学生信息连在一起，给出一个age, 在些链表中删除学生年龄等于age的学生信息。

＃I nclude /"stdio.h/"
＃I nclude /"conio.h/"

struct stu{
    char name[20];
    char sex;
    int no;
    int age;
    struct stu * next;
}*linklist;
struct stu *creatlist(int n)
{
    int I;
    //h为头结点，p为前一结点，s为当前结点
    struct stu *h,*p,*s;
    h = (struct stu *)malloc(sizeof(struct stu));
    h->next = NULL;
    p=h;
    for(i=0;i    {
        s = (struct stu *)malloc(sizeof(struct stu));
        p->next = s;
        printf(/"Please input the information of the student: name sex no age n/");
        scanf(/"%s %c %d %d/",s->name,&s->sex,&s->no,&s->age);
        s->next = NULL;
        p = s;
    }
    printf(/"Create successful!/");
    return(h);
}
void deletelist(struct stu *s,int a)
{
struct stu *p;
while(s->age!=a)
{
  p = s;
  s = s->next;
}
if(s==NULL)
  printf(/"The record is not exist./");
else
{
  p->next = s->next;
  printf(/"Delete successful!/");
}
}
void display(struct stu *s)
{
s = s->next;
    while(s!=NULL)
    {
        printf(/"%s %c %d %dn/",s->name,s->sex,s->no,s->age);
        s = s->next;
    }
}
int main()
{
    struct stu *s;
int n,age;
printf(/"Please input the length of seqlist:n/");
scanf(/"%d/",&n);
    s = creatlist(n);
    display(s);
printf(/"Please input the age:n/");
scanf(/"%d/",&age);
deletelist(s,age);
display(s);
    return 0;
}

2、实现一个函数，把一个字符串中的字符从小写转为大写。

＃I nclude /"stdio.h/"
＃I nclude /"conio.h/"

void uppers(char *s,char *us)
{
    for(;*s!='0';s++,us++)
    {
        if(*s>='a'&&*s<='z')
            *us = *s-32;
        else
            *us = *s;
    }
    *us = '0';
}
int main()
{
    char *s,*us;
    char ss[20];
    printf(/"Please input a string:n/");
    scanf(/"%s/",ss);
    s = ss;
    uppers(s,us);
    printf(/"The result is:n%sn/",us);
    getch();
}

文章出自网魂工作室http://www.ad0.cn/
C/C++面试题大汇总之微软亚洲技术中心面试题
2006年10月28日更新
C/C++面试题大汇总之微软亚洲技术中心面试题
1．进程和线程的差别。
2.测试方法
3．Heap与stack的差别。
4．Windows下的内存是如何管理的？
5．介绍.Net和.Net的安全性。
6．客户端如何访问.Net组件实现Web Service？
7．C/C++编译器中虚表是如何完成的？
8．谈谈COM的线程模型。然后讨论进程内/外组件的差别。
9．谈谈IA32下的分页机制
10．给两个变量，如何找出一个带环单链表中是什么地方出现环的？
11．在IA32中一共有多少种办法从用户态跳到内核态？
12．如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现？
13．如何截取键盘的响应，让所有的‘a’变成‘b’？
14．Apartment在COM中有什么用？为什么要引入？
15．存储过程是什么？有什么用？有什么优点？
16．Template有什么特点？什么时候用？
17．谈谈Windows DNA结构的特点和优点。
18.网络编程中设计并发服务器，使用多进程与多线程，请问有什么区别？

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

1 int func(x)

2 {

3 int countx = 0;

4 while(x)

5 {

6 countx ++;

7 x = x&(x-1);

8 }

9 return countx;

10 }

复制代码

假定x = 9999. 答案：8思路：将x转化为2进制，看含有的1的个数。

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

    答：引用就是某个目标变量的“别名”（alias），对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

    3. 将“引用”作为函数参数有哪些特点？

    （1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

    （2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

    （3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名" 的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

    4. 在什么时候需要使用“常引用”？

    如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；

    例1

11 int a ;

12 const int &ra=a;

13 ra=1; //错误

14 a=1; //正确

复制代码

例2

15 string foo( );

16 void bar(string & s);

复制代码

那么下面的表达式将是非法的：

17 bar(foo());

18 bar("hello world");

复制代码

原因在于foo（）和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

    引用型参数应该在能被定义为const的情况下，尽量定义为const .

    5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则？

    格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error！

    注意事项：

    （1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31.主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

    （2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31.虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak.（3）可以返回类成员的引用，但最好是const.这条原则可以参照Effective C++[1]的Item 30.主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

    （4）流操作符重载返回值申明为“引用”的作用：流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl；　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=.这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10；或者（x=10）=100；赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

    例3

19 ＃include <iostream.h>

20 int &put(int n);

21 int vals[10];

22 int error=-1;

23 void main()

24 {

25 put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10;

26 put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20;

27 cout<<vals[0];

28 cout<<vals[9];

29 }

30 int &put(int n)

31 {

32 if (n>=0 && n<=9 ) return vals[n];

33 else { cout<<"subscript error"; return error; }

34 }

复制代码

（5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为（（a+b） == （c+d））会永远为true而导致错误。所以可选的只剩下返回一个对象了。

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

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

    例4

35 Class A;

36 Class B : Class A{...};

37 B b;

38 A& ref = b;

复制代码

7. “引用”与指针的区别是什么？

    指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数传ref和pointer的区别。

    8. 什么时候需要“引用”？

    流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

    以上 2-8 参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx

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

    1. 结构和联合都是由多个不同的数据类型成员组成，但在任何同一时刻，联合中只存放了一个被选中的成员（所有成员共用一块地址空间），而结构的所有成员都存在（不同成员的存放地址不同）。

    2. 对于联合的不同成员赋值，将会对其它成员重写，  原来成员的值就不存在了，而对于结构的不同成员赋值是互不影响的。

    10. 下面关于“联合”的题目的输出？

    a)

39 ＃include <stdio.h>

40 union

41 {

42 int i;

43 char x[2];

44 }a;

45 void main()

46 {

47 a.x[0] = 10;

48 a.x[1] = 1;

49 printf("%d",a.i);

50 }

复制代码

答案：266 （低位低地址，高位高地址，内存占用情况是Ox010A）

b）

51 main()

52 {

53 union{ /*定义一个联合*/

54 int i;

55 struct{ /*在联合中定义一个结构*/

56 char first;

57 char second;

58 }half;

59 }number;

60 number.i=0x4241; /*联合成员赋值*/

61 printf("%c%c\n", number.half.first, mumber.half.second);

62 number.half.first='a'; /*联合中结构成员赋值*/

63 number.half.second='b';

64 printf("%x\n", number.i);

65 getch();

66 }

复制代码

答案： AB   （0x41对应'A'，是低位；Ox42对应'B'，是高位）

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

    11. 已知strcpy的函数原型：char *strcpy（char *strDest， const char *strSrc）其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy.

    答案：

67 char *strcpy(char *strDest, const char *strSrc)

68 {

69 if ( strDest == NULL || strSrc == NULL)

70 return NULL ;

71 if ( strDest == strSrc)

72 return strDest ;

73 char *tempptr = strDest ;

74 while( (*strDest++ = *strSrc++) != ‘\0’);

75 return tempptr ;

76 }

复制代码

12. 已知String类定义如下：

77 class String

78 {

79 public:

80 String(const char *str = NULL); // 通用构造函数

81 String(const String &another); // 拷贝构造函数

82 ~ String(); // 析构函数

83 String & operater =(const String &rhs); // 赋值函数

84 private:

85 char *m_data; // 用于保存字符串

86 };

复制代码

尝试写出类的成员函数实现。

答案：

87 String::String(const char *str)

88 {

89 if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断

90 {

91 m_data = new char[1] ;

92 m_data[0] = '\0' ;

93 }

94 else

95 {

96 m_data = new char[strlen(str) + 1];

97 strcpy(m_data,str);

98 }

99 }

100 String::String(const String &another)

101 {

102 m_data = new char[strlen(another.m_data) + 1];

103 strcpy(m_data,other.m_data);

104 }

105 String& String::operator =(const String &rhs)

106 {

107 if ( this == &rhs)

108 return *this ;

109 delete []m_data; //删除原来的数据，新开一块内存

110 m_data = new char[strlen(rhs.m_data) + 1];

111 strcpy(m_data,rhs.m_data);

112 return *this ;

113 }

114 String::~String()

115 {

116 delete []m_data ;

117 }

复制代码

13. .h头文件中的ifndef/define/endif 的作用？

    答：防止该头文件被重复引用。

    14. ＃include<file.h> 与＃include "file.h"的区别？

    答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h. 15.在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern “C”？

    首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。

    通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数extern "C"是连接申明（linkage declaration），被extern "C"修饰的变量和函数是按照C语言方式编译和连接的，来看看C++中对类似C的函数是怎样编译的：作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：void foo（ int x， int y ）；

    该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

    _foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo（ int x， int y ）与void foo（ int x， float y ）编译生成的符号是不相同的，后者为_foo_int_float.同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

    未加extern "C"声明时的连接方式假设在C++中，模块A的头文件如下

118 // 模块A头文件　moduleA.h

119 #ifndef MODULE_A_H

120 #define MODULE_A_H

121 int foo( int x, int y );

122 #endif

复制代码

在模块B中引用该函数：

123 // 模块B实现文件　moduleB.cpp

124 ＃include "moduleA.h"

125 foo(2,3);

复制代码

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

126 // 模块A头文件　moduleA.h

127 #ifndef MODULE_A_H

128 #define MODULE_A_H

129 extern "C" int foo( int x, int y );

130 #endif

复制代码

在模块B的实现文件中仍然调用foo（ 2，3 ），其结果是：

    （1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

    （2）连接器在为模块B的目标代码寻找foo（2，3）调用时，寻找的是未经修改的符号名_foo.

    如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo（ int x， int y ），则模块B找不到模块A中的函数；反之亦然。

    所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。

    明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧：extern "C"的惯用法（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

131 extern "C"

132 {

133 ＃include "cExample.h"

134 }

复制代码

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在。c文件中包含了extern "C"时会出现编译语法错误。

C++引用C函数例子工程中包含的三个文件的源代码如下：

135 /* c语言头文件：cExample.h */

136 #ifndef C_EXAMPLE_H

137 #define C_EXAMPLE_H

138 extern int add(int x,int y);

139 #endif

140 /* c语言实现文件：cExample.c */

141 ＃include "cExample.h"

142 int add( int x, int y )

143 {

144 return x + y;

145 }

146 // c++实现文件，调用add：cppFile.cpp

147 extern "C"

148 {

149 ＃include "cExample.h"

150 }

151 int main(int argc, char* argv[])

152 {

153 add(2,3);

154 return 0;

155 }

复制代码

如果C++调用一个C语言编写的。DLL时，当包括。DLL的头文件或声明接口函数时，应加extern "C" {}.

（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

C引用C++函数例子工程中包含的三个文件的源代码如下：

156 //C++头文件 cppExample.h

157 #ifndef CPP_EXAMPLE_H

158 #define CPP_EXAMPLE_H

159 extern "C" int add( int x, int y );

160 #endif

161 //C++实现文件 cppExample.cpp

162 ＃include "cppExample.h"

163 int add( int x, int y )

164 {

165 return x + y;

166 }

167 /* C实现文件 cFile.c

168 /* 这样会编译出错：＃include "cExample.h" */

169 extern int add( int x, int y );

170 int main( int argc, char* argv[] )

171 {

172 add( 2, 3 );

173 return 0;

174 }

复制代码

15题目的解答请参考《C++中extern “C”含义深层探索》注解：

    16. 关联、聚合（Aggregation）以及组合（Composition）的区别？

    涉及到UML中的一些概念：关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：

    从实现的角度讲，聚合可以表示为：

class A {...}  class B { A* a; .....}

    而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：

    实现的形式是：

class A{...} class B{ A a; ...}

    参考文章：http://blog.csdn.net/wfwd/archive/2006/05/30/763753.aspx

    http://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx

    17.面向对象的三个基本特征，并简单叙述之？

    1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection（private， protected，public）

    2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

    3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

    18. 重载（overload）和重写（overried，有的书也叫做“覆盖”）的区别？

    常考的题目。从定义上来说：重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

    重写：是指子类重新定义复类虚函数的方法。

    从实现原理上来说：重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func（p：integer）：integer；和function func（p：string）：integer；。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func.对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

    重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

    19. 多态的作用？

    主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。

    20. Ado与Ado.net的相同与不同？

    除了“能够让应用程序处理存储于DBMS 中的数据”这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的。NET 体系架构。众所周知。NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。

    21. New delete 与malloc free 的联系与区别？

    答案：都是在堆（heap）上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor. 22. #define DOUBLE（x） x+x ，i = 5*DOUBLE（5）； i 是多少？

    答案：i 为30.

    23. 有哪几种情况只能用intialization list 而不能用assignment？

    答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

    24. C++是不是类型安全的？

    答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast）。C#是类型安全的。

25. main 函数执行以前，还会执行什么代码？

    答案：全局对象的构造函数会在main 函数之前执行。

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

    1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

    2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

    3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

    27.struct 和 class 的区别答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。

    从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的！）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。

    28.当一个类A 中没有生命任何成员变量与成员函数，这时sizeof（A）的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）

    答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0]，A[1]…了。

    29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）

    答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。

    30. 比较C++中的4种类型转换方式？

    请参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx ，重点是static_cast， dynamic_cast和reinterpret_cast的区别和应用

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

    答案：

BOOL :    if ( !a ) or if(a)
int :     if ( a == 0)
float :   const EXPRESSION EXP = 0.000001
          if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)

    32.请说出const与#define 相比，有何优点？

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

    2）有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

    33.简述数组与指针的区别？

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

    （1）修改内容上的差别

175 char a[] = “hello”;

176 a[0] = ‘X’;

177 char *p = “world”; // 注意p 指向常量字符串

178 p[0] = ‘X’; // 编译器不能发现该错误，运行时错误

复制代码

（2）用运算符sizeof 可以计算出数组的容量（字节数）。sizeof（p），p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

179 char a[] = "hello world";

180 char *p = a;

181 cout<< sizeof(a) << endl; // 12 字节

182 cout<< sizeof(p) << endl; // 4 字节

复制代码

计算数组和指针的内存容量

183 void Func(char a[100])

184 {

185 cout<< sizeof(a) << endl; // 4 字节而不是100 字节

186 }

复制代码

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

    答案：

    a.成员函数被重载的特征：

    （1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。

    b.覆盖是指派生类函数覆盖基类函数，特征是：

    （1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。

    c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

    （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

    （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

    35. 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

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

    答案：

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

    37. main 主函数执行完毕后，是否可能会再执行一段代码，给出说明？

    答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行int fn1（void）， fn2（void）， fn3（void）， fn4 （void）；

187 void main( void )

188 {

189 String str("zhanglin");

190 _onexit( fn1 );

191 _onexit( fn2 );

192 _onexit( fn3 );

193 _onexit( fn4 );

194 printf( "This is executed first.\n" );

195 }

196 int fn1()

197 {

198 printf( "next.\n" );

199 return 0;

200 }

201 int fn2()

202 {

203 printf( "executed " );

204 return 0;

205 }

206 int fn3()

207 {

208 printf( "is " );

209 return 0;

210 }

211 int fn4()

212 {

213 printf( "This " );

214 return 0;

215 }

复制代码

The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.

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

答案：

216 #ifdef __cplusplus

217 cout<<"c++";

218 #else

219 cout<<"c";

220 #endif

复制代码

39.文件中有一组整数，要求排序后输出到另一个文件中

答案：

221 ＃include<iostream>

222 ＃include<fstream>

223 using namespace std;

224 void Order(vector<int>& data) //bubble sort

225 {

226 int count = data.size() ;

227 int tag = false ; // 设置是否需要继续冒泡的标志位

228 for ( int i = 0 ; i < count ; i++)

229 {

230 for ( int j = 0 ; j < count - i - 1 ; j++)

231 {

232 if ( data[j] > data[j+1])

233 {

234 tag = true ;

235 int temp = data[j] ;

236 data[j] = data[j+1] ;

237 data[j+1] = temp ;

238 }

239 }

240 if ( !tag )

241 break ;

242 }

243 }

244 void main( void )

245 {

246 vector<int>data;

247 ifstream in("c:\\data.txt");

248 if ( !in)

249 {

250 cout<<"file error!";

251 exit(1);

252 }

253 int temp;

254 while (!in.eof())

255 {

256 in>>temp;

257 data.push_back(temp);

258 }

259 in.close(); //关闭输入文件流

260 Order(data);

261 ofstream out("c:\\result.txt");

262 if ( !out)

263 {

264 cout<<"file error!";

265 exit(1);

266 }

267 for ( i = 0 ; i < data.size() ; i++)

268 out<<data<<" ";

269 out.close(); //关闭输出文件流

270 }

复制代码

40. 链表题：一个链表的结点结构

271 struct Node

272 {

273 int data ;

274 Node *next ;

275 };

276 typedef struct Node Node ;

复制代码

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

277 Node * ReverseList(Node *head) //链表逆序

278 {

279 if ( head == NULL || head->next == NULL )

280 return head;

281 Node *p1 = head ;

282 Node *p2 = p1->next ;

283 Node *p3 = p2->next ;

284 p1->next = NULL ;

285 while ( p3 != NULL )

286 {

287 p2->next = p1 ;

288 p1 = p2 ;

289 p2 = p3 ;

290 p3 = p3->next ;

291 }

292 p2->next = p1 ;

293 head = p2 ;

294 return head ;

295 }

复制代码

（2）已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。（保留所有结点，即便大小相同）

296 Node * Merge(Node *head1 , Node *head2)

297 {

298 if ( head1 == NULL)

299 return head2 ;

300 if ( head2 == NULL)

301 return head1 ;

302 Node *head = NULL ;

303 Node *p1 = NULL;

304 Node *p2 = NULL;

305 if ( head1->data < head2->data )

306 {

307 head = head1 ;

308 p1 = head1->next;

309 p2 = head2 ;

310 }

311 else

312 {

313 head = head2 ;

314 p2 = head2->next ;

315 p1 = head1 ;

316 }

317 Node *pcurrent = head ;

318 while ( p1 != NULL && p2 != NULL)

319 {

320 if ( p1->data <= p2->data )

321 {

322 pcurrent->next = p1 ;

323 pcurrent = p1 ;

324 p1 = p1->next ;

325 }

326 else

327 {

328 pcurrent->next = p2 ;

329 pcurrent = p2 ;

330 p2 = p2->next ;

331 }

332 }

333 if ( p1 != NULL )

334 pcurrent->next = p1 ;

335 if ( p2 != NULL )

336 pcurrent->next = p2 ;

337 return head ;

338 }

复制代码

（3）已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。（Autodesk）

答案：

339 Node * MergeRecursive(Node *head1 , Node *head2)

340 {

341 if ( head1 == NULL )

342 return head2 ;

343 if ( head2 == NULL)

344 return head1 ;

345 Node *head = NULL ;

346 if ( head1->data < head2->data )

347 {

348 head = head1 ;

349 head->next = MergeRecursive(head1->next,head2);

350 }

351 else

352 {

353 head = head2 ;

354 head->next = MergeRecursive(head1,head2->next);

355 }

356 return head ;

357 }

复制代码

41. 分析一下这段程序的输出（Autodesk）

358 class B

359 {

360 public:

361 B()

362 {

363 cout<<"default constructor"<<endl;

364 }

365 ~B()

366 {

367 cout<<"destructed"<<endl;

368 }

369 B(int i):data(i) //B(int) works as a converter ( int -> instance of B)

370 {

371 cout<<"constructed by parameter " << data <<endl;

372 }

373 private:

374 int data;

375 };

376 B Play( B b)

377 {

378 return b ;

379 }

复制代码

(1)                                            results:
int main(int argc, char* argv[])      constructed by parameter 5
{                                     destructed  B(5)形参析构
B t1 = Play(5); B t2 = Play(t1);   　 destructed  t1形参析构
return 0;　　　　　　　　　　　　　　 destructed  t2　注意顺序！
}                                     destructed  t1

(2)                                   results:
int main(int argc, char* argv[])      constructed by parameter 5
{                                     destructed  B(5)形参析构
B t1 = Play(5); B t2 = Play(10);   　 constructed by parameter 10
return 0;　　　　　　　　　　　　　　 destructed  B(10)形参析构
}                                     destructed  t2　注意顺序！
                                      destructed  t1

    42. 写一个函数找出一个整数数组中，第二大的数（microsoft）

    答案：

380 const int MINNUMBER = -32767 ;

381 int find_sec_max( int data[] , int count)

382 {

383 int maxnumber = data[0] ;

384 int sec_max = MINNUMBER ;

385 for ( int i = 1 ; i < count ; i++)

386 {

387 if ( data > maxnumber )

388 {

389 sec_max = maxnumber ;

390 maxnumber = data ;

391 }

392 else

393 {

394 if ( data > sec_max )

395 sec_max = data ;

396 }

397 }

398 return sec_max ;

399 }

复制代码

43. 写一个在一个字符串（n）中寻找一个子串（m）第一个位置的函数。

    KMP算法效率最好，时间复杂度是Ｏ（n+m）。

    44. 多重继承的内存分配问题：比如有class A ： public class B， public class C {}那么A的内存结构大致是怎么样的？

    这个是compiler-dependent的，不同的实现其细节可能不同。

    如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。

    可以参考《深入探索C++对象模型》，或者：http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx

    45. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）

    struct node { char val； node* next;}

     bool check(const node* head） {} //return false ：无环；true：有环

    一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：

400 bool check(const node* head)

401 {

402 if(head==NULL) return false;

403 node *low=head, *fast=head->next;

404 while(fast!=NULL && fast->next!=NULL)

405 {

406 low=low->next;

407 fast=fast->next->next;

408 if(low==fast) return true;

409 }

410 return false;

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

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

假定x = 9999。答案：8

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

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

答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

3. 将“引用”作为函数参数有哪些特点？

（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

4. 在什么时候需要使用“常引用”？　

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；

例1

int a;constint&ra = a;
ra = 1; // 错误a = 1; // 正确

例2

string foo( );void bar(string&s)// 那么下面的表达式将是非法的：bar(foo( ));
bar("hello world");

原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

引用型参数应该在能被定义为const的情况下，尽量定义为const 。

5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

格式：

类型标识符 &函数名（形参列表及类型说明）
{
　　//函数体}

好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!

注意：

（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

（2）不能返回函数内部new分配的内存的引用(这个要注意啦，很多人没意识到，哈哈。。。）。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

（4）流操作符重载返回值申明为“引用”的作用：

流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout <<"hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

例3

＃include <iostream.h>int&put(int n);int vals[10];int error = -1;

void main()
{
　　put(0) = 10; // 以put(0)函数值作为左值，等价于vals[0]=10;　　put(9) = 20; // 以put(9)函数值作为左值，等价于vals[9]=20;　　cout << vals[0];
　　cout << vals[9];
}

int&put(int n)
{　　if (n>=0&& n<=9 )

　　{

　　　　return vals[n];

　　}

　　else

　　{

　　　　cout << "subscript error";

　　　　return error;

　　}

（5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

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

引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例（见：C++中类的多态与虚函数的使用）。

例4

Class A;
Class B : Class A
{
　　// ...};
B b;
A&ref= b;

7. “引用”与指针的区别是什么？

指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；

而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数传ref和pointer的区别。

8. 什么时候需要“引用”？

流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

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

10. 下面关于“联合”的题目的输出？

＃include <stdio.h>
union
{　　int i;　　char x[2];
}a;void main()
{
　　a.x[0] =10;
　　a.x[1] =1;
　　printf("%d",a.i);
}

答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）

main()
{
union{ /*定义一个联合*/ int i; struct{ /*在联合中定义一个结构*/ char first; char second;
}half;
}number;
number.i=0x4241; /*联合成员赋值*/
printf("%c%c\n", number.half.first, mumber.half.second);
number.half.first='a'; /*联合中结构成员赋值*/
number.half.second='b';
printf("%x\n",number.i);
getch();
}

答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）

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

11. 已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy。

答案：

/*
编写strcpy函数（10分）
已知strcpy函数的原型是
char *strcpy(char *strDest, const char *strSrc);
其中strDest是目的字符串，strSrc是源字符串。
（1）不调用C++/C的字符串库函数，请编写函数 strcpy
（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？
答：为了实现链式表达式。 // 2分
例如 int length = strlen( strcpy( strDest, “hello world”) );*/

#include <assert.h>
#include <stdio.h>char*strcpy(char*strDest, constchar*strSrc)
{
assert((strDest!=NULL) && (strSrc !=NULL)); // 2分char* address = strDest; // 2分while( (*strDest++=*strSrc++) !='\0' )// 2分NULL; return address ; // 2分}

另外strlen函数如下：

#include<stdio.h>
#include<assert.h> int strlen( constchar*str ) // 输入参数const{
assert( str != NULL ); // 断言字符串地址非0int len = 0;while( (*str++) !='\0' )
{
len++;
} return len;
}

12. 已知String类定义如下：

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

尝试写出类的成员函数实现。

答案：

String::String(constchar*str)
{if ( str == NULL ) // strlen在参数为NULL时会抛异常才会有这步判断{
m_data =newchar[1] ;
m_data[0] ='\0' ;
}else
{
m_data =newchar[strlen(str) +1];
strcpy(m_data,str);
}
}
String::String(const String &another)
{
m_data =newchar[strlen(another.m_data) +1];
strcpy(m_data,other.m_data);
}

String& String::operator=(const String &rhs)
{if ( this==&rhs)return*this ;
delete []m_data; //删除原来的数据，新开一块内存m_data =newchar[strlen(rhs.m_data) +1];
strcpy(m_data,rhs.m_data);return*this ;
}

String::~String()
{
delete []m_data ;
}

13. .h头文件中的ifndef/define/endif 的作用？

答：防止该头文件被重复引用。

14. ＃include<file.h> 与＃include "file.h"的区别？

答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。

15.在C++程序中调用被C 编译器编译后的函数，为什么要加extern “C”？

首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。

通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数

extern "C"是连接申明(linkage declaration),被extern "C"修饰的变量和函数是按照C语言方式编译和连接的,来看看C++中对类似。

C的函数是怎样编译的：

作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

_foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

未加extern "C"声明时的连接方式

假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hint foo( int x, int y );#endif　　

在模块B中引用该函数：

// 模块B实现文件　moduleB.cpp＃include "moduleA.h"
foo(2,3);

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h#ifndef MODULE_A_H#define MODULE_A_Hextern"C"int foo( int x, int y );#endif　

在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：
（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。　　

明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧：

extern "C"的惯用法

（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern"C"
{
　　＃include"cExample.h"
}

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern"C"时会出现编译语法错误。

C++引用C函数例子工程中包含的三个文件的源代码如下：

/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H#define C_EXAMPLE_Hexternint add(int x, inty);#endif

/* c语言实现文件：cExample.c */
#include "cExample.h"int add( int x, int y )
{　　return x + y;
}

// c++实现文件，调用add：cppFile.cppextern"C"
{
　　＃include"cExample.h"
}int main(int argc, char* argv[])
{
　　add(2,3); 　　return0;
}

如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {}。

（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern"C"函数声明为extern类型。

C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件cppExample.h#ifndef CPP_EXAMPLE_H#define CPP_EXAMPLE_Hextern"C"int add( int x, int y );#endif

//C++实现文件 cppExample.cpp＃include"cppExample.h"int add( int x, int y )
{　　return x + y;
}

/* C实现文件 cFile.c
/* 这样会编译出错：＃i nclude "cExample.h" */externint add( int x, int y );int main( int argc, char* argv[] )
{
　　add( 2, 3 ); 　　return0;
}

16. 关联、聚合(Aggregation)以及组合(Composition)的区别？

涉及到UML中的一些概念：

关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；

聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：

从实现的角度讲，聚合可以表示为:

class A {...} class B { A* a; .....}

组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：

实现的形式是:

class A{...} class B{ A a; ...}

17.面向对象的三个基本特征，并简单叙述之？

1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)

2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

3. 多态：系统能够在运行时，能够根据其类型确定调用哪个重载的成员函数的能力，称为多态性。（见：C++中类的多态与虚函数的使用）

18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

常考的题目。

从定义上来说：

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

重写：是指子类重新定义父类虚函数的方法。

从实现原理上来说：

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

19. 多态的作用？

主要是两个：

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

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

20. Ado与Ado.net的相同与不同？

除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。

21. New delete 与mallocfree 的联系与区别?答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.

（可以看看：显式调用构造函数和析构函数）

22. #define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？答案：i 为30。（注意直接展开就是了） 5 * 5 + 5

23. 有哪几种情况只能用intializationlist 而不能用assignment?

答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

24. C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。

25. main 函数执行以前，还会执行什么代码？答案：全局对象的构造函数会在main 函数之前执行，为malloc分配必要的资源，等等。

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

4) 代码区。

27.struct 和 class 的区别

答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。

从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。

28.当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。

29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。

30. 比较C++中的4种类型转换方式？

重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用。(以后再补上吧）

31.分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。
答案：

BOOL : if ( !a ) or if(a)int : if ( a ==0)float : const EXPRESSION EXP =0.000001
　　if ( a < EXP&& a >-EXP)
pointer :if ( a != NULL) or if(a == NULL)

32.请说出const与#define 相比，有何优点？1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2）有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

33.简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

char a[] ="hello world";char*p = a;
cout<<sizeof(a) << endl; // 12 字节cout<<sizeof(p) << endl; // 4 字节

计算数组和指针的内存容量

void Func(char a[100])
{
　　cout<<sizeof(a) << endl; // 4 字节而不是100 字节}

35. There are twoint variables: a and b, don’t use “if”, “? :”, “switch”or other judgementstatements, find out the biggest one of the two numbers.
答案：( ( a + b ) + abs( a- b ) ) / 2

36. 如何打印出当前源文件的文件名以及源文件的当前行号？答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的

。

37. main 主函数执行完毕后，是否可能会再执行一段代码，给出说明？答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行int fn1(void), fn2(void), fn3(void),fn4 (void);

void main( void )
{
　　String str("zhanglin");
　　_onexit( fn1 );
　　_onexit( fn2 );
　　_onexit( fn3 );
　　_onexit( fn4 );
　　printf( "This is executed first.\n" );
}int fn1()
{
　　printf( "next.\n" );　　return0;
}int fn2()
{
　　printf( "executed " );　　return0;
}int fn3()
{
　　printf( "is " );　　return0;
}int fn4()
{
　　printf( "This " );　　return0;
}

The _onexit function is passed the address of a function (func) to be called whenthe program terminates normally. Successive calls to _onexit create a registerof functions that are executed in LIFO (last-in-first-out) order. The functionspassed to _onexit cannot take parameters.

38. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？
答案：

#ifdef __cplusplus
　　cout<<"c++";#else
　　cout<<"c";#endif

注意，后面很多代码啊。代码不看也罢。

39.文件中有一组整数，要求排序后输出到另一个文件中（面试官，超级喜欢考排序的。你要去面试，数据结构的那几个排序一定要非常熟悉，用笔也可以写出代码来，用笔写代码，就是这样变态啊，其实感觉没有必要这样笔试）
答案：

＃include<iostream>
＃include<fstream>usingnamespace std;void Order(vector<int>& data)//bubble sort{int count = data.size() ;int tag =false ; // 设置是否需要继续冒泡的标志位for ( int i =0 ; i < count ; i++)
{for ( int j =0 ; j < count - i -1 ; j++)
{if ( data[j] > data[j+1])
{
tag =true ;int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}if ( !tag )break ;
}
}void main( void )
{
vector<int>data;
ifstream in("c:\\data.txt");if ( !in)
{
cout<<"file error!";
exit(1);
}int temp;while (!in.eof())
{in>>temp;
data.push_back(temp);
}in.close(); //关闭输入文件流Order(data);
ofstream out("c:\\result.txt");if ( !out)
{
cout<<"file error!";
exit(1);
}for ( i =0 ; i < data.size() ; i++)out<<data[i]<<"";out.close(); //关闭输出文件流}

40. 链表题：一个链表的结点结构

struct Node
{int data ;
Node *next ;
};
typedef struct Node Node ;

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

Node * ReverseList(Node *head) //链表逆序{if ( head == NULL || head->next == NULL )return head;
Node *p1 = head ;
Node *p2 = p1->next ;
Node *p3 = p2->next ;
p1->next = NULL ;while ( p3 != NULL )
{
p2->next = p1 ;
p1 = p2 ;
p2 = p3 ;
p3 = p3->next ;
}
p2->next = p1 ;
head = p2 ;return head ;
}

(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

Node * Merge(Node *head1 , Node *head2)
{if ( head1 == NULL)return head2 ;if ( head2 == NULL)return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;while ( p1 != NULL && p2 != NULL)
{if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}if ( p1 != NULL )
pcurrent->next = p1 ;if ( p2 != NULL )
pcurrent->next = p2 ;return head ;
}

(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。(Autodesk)答案：

Node * MergeRecursive(Node *head1 , Node *head2)
{if ( head1 == NULL )return head2 ;if ( head2 == NULL)return head1 ;
Node *head = NULL ;if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}return head ;
}

41. 分析一下这段程序的输出(Autodesk)

class B
{public:
B()
{
cout<<"default constructor"<<endl;
}~B()
{
cout<<"destructed"<<endl;
}
B(int i):data(i) //B(int) works as a converter ( int ->instance of B){
cout<<"constructed by parameter "<< data <<endl;
}private:int data;
};

B Play( B b)
{return b ;
}
(1) results:int main(int argc, char* argv[]) constructedby parameter 5
{ destructed B(5)形参析构
B t1 = Play(5); B t2 = Play(t1); 　 destructed t1形参析构return0;　　　　　　　　　　　　　　 destructed t2　注意顺序！
} destructed t1
(2) results:int main(int argc, char* argv[]) constructedby parameter 5
{ destructed B(5)形参析构
B t1 = Play(5); B t2 = Play(10); 　 constructed by parameter 10return0;　　　　　　　　　　　　　　 destructed B(10)形参析构
} destructed t2　注意顺序！
destructed t1

42. 写一个函数找出一个整数数组中，第二大的数（microsoft）
答案：

constint MINNUMBER =-32767 ;int find_sec_max( int data[] , int count)
{int maxnumber = data[0] ;int sec_max = MINNUMBER ;for ( int i =1 ; i < count ; i++)
{if ( data[i] > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data[i] ;
}else
{if ( data[i] > sec_max )
sec_max = data[i] ;
}
}return sec_max ;
}

43. 写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。

KMP算法效率最好，时间复杂度是Ｏ(n+m)。

44. 多重继承的内存分配问题：比如有class A : public class B, public classC {} 那么A的内存结构大致是怎么样的？

这个是compiler-dependent的, 不同的实现其细节可能不同。
如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。
可以参考《深入探索C++对象模型》

45. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）

struct node { char val; node* next;}bool check(const node* head) {} //return false : 无环；true: 有环一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：bool check(const node* head)
{if(head==NULL) returnfalse;
node *low=head, *fast=head->next;while(fast!=NULL && fast->next!=NULL)
{
low=low->next;
fast=fast->next->next;if(low==fast) returntrue;
}returnfalse;
}

1.C与C++的异同，优劣；
2．C，C++，VC，BC，TC的区别；
3．C++中try…catch关键字的用法与优点；
4．枚举的用法，以及它与宏的区别；
5．const的用法，以及声明const变量与宏的区别；
const的用法有四种：1. const常量，如const int max = 100；2. const 修饰类的数据成员；3. const修饰指针的情况；4. 在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。
 区别：1.const常量有数据类型，而宏常量没有数据类型；2.编译器可以对前者进行类型安全检查，而对后者只能进行字符替换，没有类型安全检查，而且字符替换可能会带来料想不到的边界效应；3. 有些集成化工具可以对const常量进行调试，但不能对宏量进行调试。
6．C++中引用与指针的区别；
 答：1 引用实际上是所引用的对象或变量的别名，而指针是包含所指向对象或变量的地址的变量。
 2 引用在定义时必须初始化，而指针在定义时不初始化。
 3 不可以有努NULL的引用，而可以有指向NULL的指针。
 4 引用在初始化后不可以改变引用关系，而指针可以随时指向其他对象（非const指针）。
7．C++中virtual与inline的含义分别是什么？
 答：在基类成员函数的声明前加上virtual关键字，意味着将该成员函数声明为虚函数。
 inline与函数的定义体放在一起，使该函数称为内联。inline是一种用于实现的关键字，而不是用于声明的关键字。
虚函数的特点；如果希望派生类能够重新定义基类的方法，则在基类中将该方法定义为虚方法，这样可以启用动态联编。
内联函数的特点；使用内联函数的目的是为了提高函数的运行效率。内联函数体的代码不能过长，因为内联函数省去调用函数的时间是以代码膨胀为代价的。内联函数不能包含循环语句，因为执行循环语句要比调用函数的开销大。
一个函数能否即是虚函数又是内联函数？可以，建议不使用？
8．以下关键字的含义与用法：
extern，extern “C”，static，explicit，register，#undef，#ifndef
9．什么是函数重载与覆盖？
为什么C不支持函数重载？
为什么C++能支持函数重载？
10．VC中，编译工具条内的Debug与Release选项是什么含义？

Debug 通常称为调试版本，它包含调试信息，并且不作任何优化，便于程序员调试程序。Release 称为发布版本，它往往是进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好地使用。Debug带有大量的调试代码，运行时需要相应的运行库，发布模式程序紧凑不含有调试代码和信息，直接可以运行（如果不需要运行库）
11．编写my_memcpy函数，实现与库函数memcpy类似的功能，不能使用任何库函数；
 void* mymemcpy(void* pvTo, const char* pvFrom, size_t size)
 { assert((dest != NULL) && (src != NULL));
   byte* psTo = (byte*)pvTo;
   byte* psFrom = (byte*)pvFrom;
   while (size– > 0)
   {*psTo++ = *psFrom++;}
   return pvTo;
 }
12．编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数；
 答：char* my_strcpy(char* strdest, const char* strsrc)
 { assert((strdest != NULL) && (strsrc != NULL))
   char* address = strdest;
   while((*strdest++ = *strsrc++) != NULL)
   return address;
 }
13．编写gbk_strlen函数，计算含有汉字的字符串的长度，汉字作为一个字符处理；
已知：汉字编码为双字节，其中首字节<0，尾字节在0~63以外；（如果一个字节是-128~127）
14．函数assert的用法?
答：断言assert是仅在debug版本起作用的宏，用于检查“不应该“发生的情况。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。
15．为什么在头文件的最前面都会看到这样的代码：
#ifndef _STDIO_H_
#define _STDIO_H_

头文件中的#ifndef一般格式是这样的#ifndef <标识> ，#define <标识>；<标识>在理论上来说可以是自由命名的，但每个头文件的这个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写，前后加下划线，并把文件名中的“.”也变成下划线，如：stdio.h

#ifndef _STDIO_H_
#define _STDIO_H_
16．为什么数组名作为参数，会改变数组的内容，而其它类型如int却不会改变变量的值？
答：当数组名作为参数时，传递的实际上是地址。而其他类型如int作为参数时，由于函数参数值实质上是实参的一份拷贝，被调函数内部对形参的改变并不影响实参的值。
1．实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。
2．写一个函数，将其中的\t都转换成4个空格。
　　3．Windows程序的入口是哪里？写出Windows消息机制的流程。
　　4．如何定义和实现一个类的成员函数为回调函数？
　　5．C++里面是不是所有的动作都是main()引起的？如果不是，请举例。
　　6．C++里面如何声明const void f(void)函数为C程序中的库函数？
　　7．下列哪两个是等同的
　　int b;
　　A const int* a = &b;
　　B const* int a = &b;
　　C const int* const a = &b;
　　D int const* const a = &b;
　　8．内联函数在编译时是否做参数类型检查？
　　void g(base & b){
　　 b.play;
　　}
　　void main(){
　　 son s;
　　 g(s);
　　 return;
　　}
3、WinMain
 while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0)
 {
 if (bRet == -1)
 {
 // handle the error and possibly exit
 }
 else
 {
 TranslateMessage(&msg);
 DispatchMessage(&msg);
 }
 }

1. C++的类和C里面的struct有什么区别？
   struct成员默认访问权限为public，而class成员默认访问权限为private
2. 析构函数和虚函数的用法和作用
   析构函数是在对象生存期结束时自动调用的函数，用来释放在构造函数分配的内存。
   虚函数是指被关键字virtual说明的函数，作用是使用C++语言的多态特性

3. 全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的?
   1) 全局变量的作用用这个程序块,而局部变量作用于当前函数
   2) 前者在内存中分配在全局数据区,后者分配在栈区
   3) 生命周期不同：全局变量随主程序创建和创建，随主程序销毁而销毁，局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在
   4) 使用方式不同：通过声明后全局变量程序的各个部分都可以用到，局部变量只能在局部使用

4. 有N个大小不等的自然数（1--N），请将它们由小到大排序.要求程序算法：时间复杂度为O(n)，空间复杂度为O(1)。
void sort(int e[], int n)
{
   int i;
   int t;
   for (i=1; i<n+1; i++)
   {
       t = e[e[i]];
       e[e[i]] = e[i];
       e[i] = t;
   }
}

5. 堆与栈的去区别
   A. 申请方式不同
       Stack由系统自动分配，而heap需要程序员自己申请，并指明大小。
   B. 申请后系统的响应不同
       Stack：只要栈的剩余空间大于申请空间，系统就为程序提供内存，否则将抛出栈溢出异常
       Heap：当系统收到程序申请时，先遍历操作系统中记录空闲内存地址的链表，寻找第一个大于所申请空间的堆结点，然后将该结点从空间结点链表中删除，并将该结点的空间分配给程序。另外，大多数系统还会在这块内存空间中的首地址处记录本次分配的大小，以便于delete语句正确释放空间。而且，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动将多余的那部分重新放入空闲链表。
   C. 申请大小限制的不同
       Stack：在windows下，栈的大小是2M（也可能是1M它是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
       Heap：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
   D. 申请效率的比较：
       栈由系统自动分配，速度较快。但程序员是无法控制的。
       堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
   另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。
   E. 堆和栈中的存储内容
       栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
       堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

6. 含参数的宏与函数的优缺点
   宏：
       优点：在预处理阶段完成，不占用编译时间，同时，省去了函数调用的开销，运行效率高
       缺点：不进行类型检查，多次宏替换会导致代码体积变大，而且由于宏本质上是字符串替换，故可能会由于一些参数的副作用导致得出错误的结果。
   函数：
       优点：没有带参数宏可能导致的副作用，进行类型检查，计算的正确性更有保证。
       缺点：函数调用需要参数、返回地址等的入栈、出栈开销，效率没有带参数宏高

    PS：宏与内联函数的区别
   内联函数和宏都是在程序出现的地方展开，内联函数不是通过函数调用实现的，是在调用该函数的程序处将它展开（在编译期间完成的）；宏同样是；
   不同的是：内联函数可以在编译期间完成诸如类型检测，语句是否正确等编译功能；宏就不具有这样的功能，而且宏展开的时间和内联函数也是不同的（在运行期间展开）

7. Windows程序的入口是哪里？写出Windows消息机制的流程
   Windows程序的入口是WinMain()函数。
   Windows应用程序消息处理机制：
       A. 操作系统接收应用程序的窗口消息，将消息投递到该应用程序的消息队列中
       B. 应用程序在消息循环中调用GetMessage函数从消息队列中取出一条一条的消息，取出消息后，应用程序可以对消息进行一些预处理。
       C. 应用程序调用DispatchMessage，将消息回传给操作系统。
       D. 系统利用WNDCLASS结构体的lpfnWndProc成员保存的窗口过程函数的指针调用窗口过程，对消息进行处理。

8. 如何定义和实现一个类的成员函数为回调函数
   A.什么是回调函数?
       简而言之，回调函数就是被调用者回头调用调用者的函数。
       使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个被调用函数。而该被调用函数在需要的时候，利用传递的地址调用回调函数。
       回调函数，就是由你自己写的，你需要调用另外一个函数，而这个函数的其中一个参数，就是你的这个回调函数名。这样，系统在必要的时候，就会调用你写的回调函数，这样你就可以在回调函数里完成你要做的事。

    B.如何定义和实现一个类的成员函数为回调函数
       要定义和实现一个类的成员函数为回调函数需要做三件事：
       a．声明；
       b．定义；
       c．设置触发条件，就是在你的函数中把你的回调函数名作为一个参数，以便系统调用
       如：
           一、声明回调函数类型
               typedef void (*FunPtr)(void);
           二、定义回调函数
               class A
               {
               public:
                   A();
                   static void callBackFun(void)   //回调函数，必须声明为static
                   {
                       cout<<"callBackFun"<<endl;
                   }
                   virtual ~A();
               };

            三、设置触发条件
               void Funtype(FunPtr p)
               {
                  p();
               }
               void main(void)
               {
                   Funtype(A::callBackFun);
               }

   C. 回调函数与API函数
   回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的；而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调函数，在需要调用时，只需引用这个函数指针和相关的参数指针。