C/C++ 经典面试题汇总

为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明，但是只在一个地方定义。加入extern修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。  

说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。

bool型数据：  if(flag) { A; } else { B；}

int型数据：   if(0==flag) { A; } else { B; }

指针变量:     if(NULL==flag) { A; } else { B; }

float型数据： #define NORM (0.000001) 
             if((flag>=-NORM) && (flag<=NORM)) { A; } else { B; }

sizeof和strlen有以下区别：  ? 

1、sizeof：一个运算符
   strlen：一个库函数

2、sizeof：参数可以是类型、变量
   strlen：只能以字符串作参数
   
3、sizeof：类型做参数时，可以省略括号
   strlen：参数必须加括号
   
4、sizeof：计算的是数据类型占内存的大小
   strlen：计算的是字符串实际的长度
   
5、sizeof：编译阶段计算出结果
   strlen：运行时阶段才计算出结果
   
6、sizeof：数组做参数时不退化
   strlen：数组做参数时退化为指针
   
7、其他

注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。最容易混淆为函数的操作符就是sizeof。

在C中static用来修饰局部静态变量和外部静态变量、函数。而C++中除了上述功能外，还用来定义类的成员变量和函数。即静态成员和静态成员函数。  

注意：编程时static的记忆性，和全局性的特点可以让在不同时期调用的函数进行通信，传递信息，而C++的静态成员则可以在多个对象实例间进行通信，传递信息。

malloc和new有以下不同：  
1、new、delete 是操作符，可以重载，只能在C++中使用。 
2、malloc、free是函数，可以覆盖，C、C++中都可以使用。  
3、new 可以调用对象的构造函数，对应的delete调用相应的析构函数。 
4、malloc仅仅分配内存，free仅仅回收内存，并不执行构造和析构函数  
5、new、delete返回的是某种数据类型指针，malloc、free返回的是void指针。  

注意：malloc申请的内存空间要用free释放，而new申请的内存空间要用delete释放，不要混用。因为两者实现的机理不同。

#define MIN(a,b) ((a)<=(b)?(a):(b))

可以，因为指针和普通变量一样，有时也有变化程序的不可控性。常见例：子中断服务子程序修改一个指向一个buffer的指针时，必须用volatile来修饰这个指针。  

说明：指针是一种普通的变量，从访问上没有什么不同于其他变量的特性。其保存的数值是个整型数据，和整型变量不同的是，这个整型数据指向的是一段内存地址。

#include<stdio.h>

void main( void )
{
    int a[5]= {1,2,3,4,5};
    int *ptr=(int *)(&a+1);
    printf("%d,%d",*(a+1),*(ptr-1));
    return;
}

输出结果：2,5  

注意：数组名a可以作数组的首地址，而&a是数组的指针。

思考，将原式的int *ptr=(int *)(&a+1);改为int *ptr=(int *)(a+1);时
输出结果将是: 2,1

一个C、C++程序编译时内存分为5大存储区：堆区、栈区、全局区、文字常量区、程序代码区。

C、C++中内存分配方式可以分为三种：  
1、从静态存储区域分配：  
内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。速度快、不容易出错，因为有系统会善后。例如全局变量，static变量等。  
2、在栈上分配： 

在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
3、从堆上分配：  

即动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定，使用非常灵活。如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，另外频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

三者主要有以下不同之处：  

1、操作对象不同，strcpy的两个操作对象均为字符串，sprintf的操作源对象可以是多种数据类型，目的操作对象是字符串，memcpy 的两个对象就是两个任意可操作的内存地址，并不限于何种数据类型。 
2、执行效率不同，memcpy最高，strcpy次之，sprintf的效率最低。 

3、实现功能不同，strcpy主要实现字符串变量间的拷贝，sprintf主要实现其他数据类型格式到字符串的转化，memcpy主要是内存块间的拷贝。  

说明：strcpy、sprintf与memcpy都可以实现拷贝的功能，但是针对的对象不同，根据实际需求，来选择合适的函数实现拷贝功能。

int *ptr;
ptr=(int*)0x67a9;
*ptr=0xaa66;

面向对象的三大特征是封装性、继承性和多态性： 

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

继承性：广义的继承有三种实现形式：实现继承（使用基类的属性和方法而无需额外编码的能力)、可视继承(子窗体使用父窗体的外观和实现代码)、接口继承(仅使用属性和方法,实现滞后到子类实现)。  ? 
多态性：是将父类对象设置成为和一个或更多它的子对象相等的技术。用子类对象给父类对象赋值之后，父类对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

1、缺省构造函数 ? 
2、缺省拷贝构造函数? 
3、缺省析构函数 
4、缺省赋值运算符? 
5、缺省取址运算符  ? 
6、const

拷贝构造函数和赋值运算符重载有以下两个不同之处：
 
1、拷贝构造函数生成新的类对象，而赋值运算符不能。 

2、由于拷贝构造函数是直接构造一个新的类对象，所以在初始化这个对象之前不用检验源对象是否和新建对象相同。而赋值运算符则需要这个操作，另外赋值运算中如果原来的对象中有内存分配要先把内存释放掉

1、重写和重载主要有以下几点不同：
  ? 
范围的区别：被重写的和重写的函数在两个类中，而重载和被重载的函数在同一个类中。  ? 

参数的区别：被重写函数和重写函数的参数列表一定相同，而被重载函数和重载函数的参数列表一定不同。  ? 

virtual的区别：重写的基类中被重写的函数必须要有virtual修饰，而重载函数和被重载函数可以被virtual修饰，也可以没有。  

2、隐藏和重写、重载有以下几点不同：  ? 

范围的不同：和重写一样，隐藏函数和被隐藏函数不在同一个类中。  ? 
参数的区别：隐藏函数和被隐藏的函数的参数列表可以相同，也可不同，但是函数名肯定要相同。 当参数不相同时，无论基类中的参数是否被virtual修饰，基类的函数都是被隐藏，而不是被重写。 


说明：虽然重载和覆盖都是实现多态的基础，但是两者实现的技术完全不相同，达到的目的也是完全不同的，覆盖是动态态绑定的多态，而重载是静态绑定的多态。

编译器发现一个类中有虚函数，便会立即为此类生成虚函数表 vtable。虚函数表的各表项为指向对应虚函数的指针。编译器还会在此类中隐含插入一个指针vptr（对vc编译器来说，它插在类的第一个位置上）指向虚函数表。调用此类的构造函数时，在类的构造函数中，编译器会隐含执行vptr与vtable的关联代码，将vptr指向对应的vtable，将类与此类的vtable联系了起来。另外在调用类的构造函数时，指向基础类的指针此时已经变成指向具体的类的this指针，这样依靠此this指针即可得到正确的vtable。如此才能真正与函数体进行连接，这就是动态联编，实现多态的基本原理。  

注意：一定要区分虚函数，纯虚函数、虚拟继承的关系和区别。牢记虚函数实现原理，因为多态C++面试的重要考点之一，而虚函数是实现多态的基础。

数组和链表有以下几点不同： 
 
1、存储形式：数组是一块连续的空间，声明时就要确定长度。链表是一块可不连续的动态空间，长度可变，每个结点要保存相邻结点指针。  

2、数据查找：数组的线性查找速度快，查找操作直接使用偏移地址。链表需要按顺序检索结点，效率低。  

3、数据插入或删除：链表可以快速插入和删除结点，而数组则可能需要大量数据移动。  
4、越界问题：链表不存在越界问题，数组有越界问题。  

说明：在选择数组或链表数据结构时，一定要根据实际需要进行选择。数组便于查询，链表便于插入删除。数组节省空间但是长度固定，链表虽然变长但是占了更多的存储空间。

相同：队列和栈都是线性存储结构
不同：插入和删除数据的操作不同，队列是“先进先出”，栈是“后进先出”

void Bubble(int array[], int size)
{
    int i,j;

    for(i=0; i<size; i++)
    {
        for(j=i+1; j<size; j++)
        {
            if(array[i]>array[j])
            {
                array[i]=array[i]^array[j];
                array[j]=array[i]^array[j];
                array[i]=array[j]^array[i];
            }
        }
    }
}

void Sort(int array[], int size)
{
    int i,j,k;

    for(i=0; i<size; i++)
    {
        k=i;
        for(j=i+1; j<size; j++)
        {
            if(array[j]<array[k])
            {
                k=j;
            }
        }

        if(i!=k)
        {
            array[i]=array[i]^array[k];
            array[k]=array[k]^array[i];
            array[i]=array[i]^array[k];
        }
    }
}

编程规范可总结为：程序的可行性，可读性、可移植性以及可测试性。  

说明：这是编程规范的总纲目，面试者不一定要去背诵上面给出的那几个例子，应该去理解这几个例子说明的问题，想一想，自己如何解决可行性、可读性、可移植性以及可测试性这几个问题，结合以上几个例子和自己平时的编程习惯来回答这个问题。

代码一是错的，代码二是正确的。  

说明：在数据安全的情况下大类型的数据向小类型的数据转换一定要显示的强制类型转换。

自动转换遵循以下规则：

1) 若参与运算量的类型不同，则先转换成同一类型，然后进行运算。

2) 转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。

     a.若两种类型的字节数不同，转换成字节数高的类型

     b.若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型

3) 所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

4) char型和short型参与运算时，必须先转换成int型。

5) 在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

1、&和|对操作数进行求值运算，&&和||只是判断逻辑关系
2、&&和||在在判断左侧操作数就能确定结果的情况下就不再对右侧操作数求值

1、引用必须被初始化，但是不分配存储空间。指针不声明时初始化，在初始化的时候需要分配存储空间。  
2、修改区别：引用初始化以后不能被改变，指针可以改变所指的对象。  
3、非空区别：不存在指向空值的引用，但是存在指向空值的指针。  
4、合法性区别：使用引用前不需检测合法性，指针应该被检测，防止为空

5、应用区别：当可能指向空对象或根据需要指向不同对象时，用指针，否则应该用引用

注意：引用作为函数参数时，会引发一定的问题，因为让引用作参数，目的就是想改变这个引用所指向地址的内容，而函数调用时传入的是实参，看不出函数的参数是正常变量，还是引用，因此可能会引发错误。所以使用时一定要小心谨慎。

1、用法不同：typedef用来定义一种数据类型的别名，增强程序的可读性。define主要用来定义常量，以及书写复杂使用频繁的宏。  

2、执行时间不同：typedef是编译过程的一部分，有类型检查的功能。define是宏定义，是预编译的部分，其发生在编译之前，只是简单的进行字符串的替换，不进行类型的检查。
3、作用域不同：typedef有作用域限定。define不受作用域约束，只要是在define声明后的引用都是正确的。  
4、对指针的操作不同：typedef和define定义的指针时有很大的区别。  

注意：typedef定义是语句，因为句尾要加上分号。而define不是语句，千万不能在句尾加分号。

const用来定义一个只读的变量或对象。
主要优点：便于类型检查、同宏定义一样可以方便地进行参数的修改和调整、节省空间，避免不必要的内存分配、可为函数重载提供参考。  

说明：const修饰函数参数，是一种编程规范的要求，便于阅读，一看即知这个参数不能被改变，实现时不易出错。

static在C中主要用于定义全局静态变量、定义局部静态变量、定义静态函数。在C++中新增了两种作用：定义静态数据成员、静态函数成员。

extern标识的变量或者函数声明其定义在别的文件中，提示编译器遇到此变量和函数时在其它模块中寻找其定义。

在程序中，流操作符>>和<<经常连续使用。因此这两个操作符的返回值应该是一个仍旧支持这两个操作符的流引用。其他的数据类型都无法做到这一点。

指针常量是指定义了一个指针，这个指针的值只能在定义时初始化，其他地方不能改变。
常量指针是指定义了一个指针，这个指针指向一个只读的对象，不能通过常量指针来改变这个对象的值。  

指针常量强调的是指针的不可改变性，而常量指针强调的是指针对其所指对象的不可改变性。 

注意：无论是指针常量还是常量指针，其最大的用途就是作为函数的形式参数，保证实参在被调用函数中的不可改变特性。

请写出以下代码的打印结果：

#include <iostream.h>
#include <string.h>
void main(void)
{
    char str[13]="Hello world!";
    char *pStr="Hello world!";

    cout<<sizeof(str)<<endl;
    cout<<sizeof(pStr)<<endl;
    cout<<strlen(str)<<endl;
    cout<<strlen(pStr)<<endl;
    return;
}

答案：

13
4
12
12

“野指针”产生原因及解决办法如下：  

1、指针变量声明时没有被初始化。解决办法：指针声明时初始化，可以是具体的地址值，也可让它指向NULL。  
2、指针被 free 或者 delete 之后，没有置NULL。解决办法：指针指向的内存空间被释放后指针应该指向NULL。  

3、指针操作超越了变量的作用范围。解决办法：在变量的作用域结束前释放掉变量的地址空间并且让指针指向NULL。

常引用的引入主要是为了避免使用变量的引用时，在不知情的情况下改变变量的值。常引用主要用于定义一个普通变量的只读属性的别名、作为函数的传入形参，避免实参在调用函数中被意外的改变。 

说明：很多情况下，需要用常引用做形参，被引用对象等效于常对象，不能在函数中改变实参的值，这样的好处是有较高的易读性和较小的出错率。

while(1) { }

说明：很多种途径都可实现同一种功能，但是不同的方法时间和空间占用度不同，特别是对于嵌入式软件，处理器速度比较慢，存储空间较小，所以时间和空间优势是选择各种方法的首要考虑条件。

#define BIT3 (0x1 << 3 )
Satic int a;

/*将a第3位置1*/
void set_bit3( void )
{
    a |= BIT3;
}
/*将a第3位清零*/
void set_bit3( void )
{
    a &= ~BIT3;
}

中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展——让标准
C支持中断。具体代表事实是，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义一个中断服务子程序(ISR)，请评论以下这段代码。

__interrupt double compute_area (double radius)
{
    double area = PI * radius * radius;
    printf(" Area = %f", area);
    return area;
}

主要有以下四个问题： 

1、ISR 不能返回一个值。  
2、ISR 不能传递参数。  
3、在ISR 中做浮点运算是不明智的。 
4、printf()经常有重入和性能上的问题。

构造函数不能是虚函数。而且不能在构造函数中调用虚函数，因为创建一个对象时我们总是要明确指定对象的类型。析构函数可以是虚函数，而且，在一个复杂类结构中，这往往是必须的。析构函数也可以是纯虚函数，但纯虚析构函数必须有定义体，因为析构函数的调用是在子类中隐含的。

面向对象可以理解成对待每一个问题，都是首先要确定这个问题由几个部分组成，而每一个部分其实就是一个对象。然后再分别设计这些对象，最后得到整个程序。传统的程序设计多是基于功能的思想来进行考虑和设计的，而面向对象的程序设计则是基于对象的角度来考虑问题。这样做能够使得程序更加的简洁清晰。

#include<stdio.h>
#define product(x) (x*x)
int main()
{
    int i=3,j,k;
    j=product(i++);
    k=product(++i);
    printf("j=%d,k=%d",j,k);
    return 0;
}

答案：j=9,k=49

            main:
00401334:   push %ebp
00401335:   mov %esp,%ebp
00401337:   and $0xfffffff0,%esp
0040133a:   sub $0x20,%esp
117       {
0040133d:   call 0x401950 <__main>
118           int i=3,j,k;
00401342:   movl $0x3,0x1c(%esp)
119           j=product(i++);
0040134a:   mov 0x1c(%esp),%eax
0040134e:   imul 0x1c(%esp),%eax
00401353:   mov %eax,0x18(%esp)
00401357:   incl 0x1c(%esp)
0040135b:   incl 0x1c(%esp)
120           k=product(++i);
0040135f:   incl 0x1c(%esp)
00401363:   incl 0x1c(%esp)
00401367:   mov 0x1c(%esp),%eax
0040136b:   imul 0x1c(%esp),%eax
00401370:   mov %eax,0x14(%esp)
121           printf("j=%d,k=%d",j,k);
00401374:   mov 0x14(%esp),%eax
00401378:   mov %eax,0x8(%esp)
0040137c:   mov 0x18(%esp),%eax
00401380:   mov %eax,0x4(%esp)
00401384:   movl $0x403024,(%esp)
0040138b:   call 0x401bc0 <printf>
122           return 0;
00401390:   mov $0x0,%eax
123       }

int i=1,j=2;
int k=i+++j;
cout<<k<<endl;

答案：3

提示：k=i+++j=(i++)+j;

char foo(void)
{
    unsigned int a=6;
    int b=-20;
    char c;
    
    (a+b>6)?(c=1):(c=0);
    return c;
}

答案：1

/*扫描字符串，跳过空格，遇上数字或正负符号开始做转换，遇到非数字或字符串结束时(‘/0‘)才结束转换并返回结果*/
int myAtoi(const char * str)
{

    #define FALSE (0)
    #define TRUE (1)
    int sum=0,begin=0,i;
    int minus=FALSE;
    while(*str!=‘\0‘)
    {
        if(begin==0 && ((isdigit(*str)) || *str==‘-‘ || *str==‘+‘) )
        {
            begin=1;
            if(*str == ‘-‘)
            {
                minus=TRUE;
                str++;
            }
        }
        else if(begin==1 && !isdigit(*str))
        {
            break;
        }

        if(begin==1)
        {
            sum=sum*10+(*str-‘0‘);
        }

        str++;
    }

    return minus? -sum : sum;
}

int i = 1;

void main()

{

    int i = i;

}

A. The i within main will have an undefined value. （main()里的i是一个未定义值）

B. The i within main will have a value of 1.（main()里的i值为1）

C. The compiler will not allow this statement. （编译器不允许这种写法）

D. The i within main will have a value of 0. （main()里的i值为0）

答案：A

#include <iostream>

using namespace std;

int main()

{

    int x=2,y,z;

    x *=(y=z=5);
    cout << x << endl;

    z=3;

    x ==(y=z);
    cout << x << endl;

    x =(y==z);
    cout << x << endl;

    x =(y&z);
    cout << x << endl;

    x =(y&&z);
    cout << x << endl;

    y=4;

    x=(y|z);
    cout << x << endl;

    x=(y||z);
    cout << x << endl;

    return 0;

}

答案：

10
10
1
3
1
7
1

#include   <iostream>

using namespace std;

int func(int x)
{
    int count = 0;

    while(x)
    {
        count ++;
        x=x&(x-1);
    }   

    return count;
}       

int main()
{
    cout << func(9999) << endl;

    return 0;
}

答案：8

解析：本题func函数返回值是形参x转化成二进制后包含1的数量。理解这一点就很容易答出来了。9999转化为二进制是：9999：10011100001111

#include <stdio.h>
#include <stdlib.h>

void Binary(int decimal)
{
    unsigned int i=sizeof(int)*8;

    while(i>0)
    {
        printf("%d",(decimal>>(i-1)&1));
        i--;
    }
}

int main()
{
    int num;
    puts("please input a num:");
    scanf("%d", &num);

    Binary(num);

    return 0;
}

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

1、 编译器处理方式不同
define宏是在预处理阶段展开。
const常量是编译运行阶段使用。
2、类型和安全检查不同
define宏没有类型，不做任何类型检查，仅仅是展开。
const常量有具体的类型，在编译阶段会执行类型检查。
3、存储方式不同
define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。
const常量会在内存中分配(可以是堆中也可以是栈中)。
4、const  可以节省空间，避免不必要的内存分配
5、 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。
6、C++语言可以用const定义常量，也可以用#define定义常量，但是前者比后者有更多的优点:
7、有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

#include <iostream.h>

void GetMemory(char *p, int num)
{
    p = (char *)malloc(sizeof(char) * num);
}

int main()
{
    char *str = NULL;

    GetMemory(str, 100);
    strcpy(str, "hello");

    return 0;
}

答案：程序崩溃。因为GetMemory并不能传递动态内存，Test函数中的str一直都是NULL。

一种是栈的形式:char array[5];
一种是堆的形式:char *array; array=(char *)malloc(sizeof(char)*5);//C++: array=new char[5];

提示：第一种形式空间分配的大小可能会受操作系统的限制,比如windows会限制在2M;第二种形式成空间分配很灵活，想分配多少分配多少，只要RAM够大。

答案：char *array[2]={"China","Beijing"};

提示：首先明确一个概念，就是指向数组的指针，和存放指针的数组。
指向数组的指针:char (*array)[5];含义是一个指针，指向存放5个字符的数组的。
存放指针的数组:char *array[5];含义是一个数组，其中存放了5个指向字符型数据的指针。

答案：支持C,C++,Java,Obj- C,Ada,Fortran,Pascal,Modula-3等语言。

答案：－1

答案：C：limits.h  

     C++：climits

答案：用static修饰就可以了

答案：含义：(a++)+ (++b)

1、按最长匹配原则确定被选的词型;
2、如果一个字符串能为若干个词型匹配，则排列在最前面的词型被选中。

答案：含义是向编译器指明变量的内容可能会由于其他程序的修改而变化。提示编译器在用到这个变量时必须每次都小心地重新读取这个变量的 ，而不是使用保存在寄存器里的备份

答案：可以用引用头文件的方式，也可以用extern关键字

答案：可以，在不同的C文件中以static形式来声明同名全局变量。

提示：可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初 ，此时连接不会出错

答案：能，局部会屏蔽全局。要用全局变量，C++中需要使用"::"；C中可用extern或指针

#include <stdio.h>

int a=10;
int main()
{
    int a=5;
    {
        extern int a;
        printf("%d\n",a);
    }
    return 0;
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
int g_nTest;

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

{

    int* pTest = &g_nTest;

    int g_nTest = 100;

    printf("%d %d\n", *pTest, g_nTest);    

    return 0;


}

static全局变量与普通的全局变量区别：static全局变量只能在本文件单元中被引用; 普通的全局变量可在源程序的各个文件单元被引用
static局部变量和普通局部变量区别：存储区域不同、生存期不同，static局部变量在静态区域存储，只被初始化一次，下一次依据上一次结果值；普通局部变量在栈中存储，函数结束自动释放
static函数与普通函数区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

设2个空栈为A,B

入队:
(1)判断栈A是否已满; 

(2)如A未满，则新元素push入栈A;
(3)如A已满，则判断栈B是否为空

(4)如B为空，则将栈A中所有元素依次pop出并push到栈B，然后新元素push入栈A

(5)如B不空，则给出提示

出队:
(1)判断栈B是否为空;
(2)如B不空，则直接弹出顶元素;

(3)如B为空，则判断栈A是否为空

(4)如A不空，则将栈A中所有元素依次pop出并push到栈B，然后弹出顶元素; 

(5)如A为空，则给出提示

答案：long atol(const char *nptr); 功能: 把字符串转换成长整型数

答案：c用宏定义，c++用inline

char * const p;
char const * p
const char *p

char * const p; //常量指针，p的指向不可以修改
char const * p;//指向常量的指针，指向的常量不可以改
const char *p; /同char const *p

提示：由于没有 const *的运算，若出现 const * 的形式，则const实际上是修饰前面的。char const*p,由于没有const*运算，则const实际上是修饰前面的char，因此char const*p等价于const char*p

答案：全局变量储存在静态数据库，局部变量在堆栈

答案：没有回收垃圾资源

答案：O(n^2)

答案：实型

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

Status ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;

    current = L->next;  /* p1指向链表头节点的下一个节点 */
    pnext = current->next;
    current->next = NULL;

    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    L->next = current;  /* 将链表头节点指向p1 */
    return L;
}

Status ListReverse2(LinkList L)
{

    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }

    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
    }
    return L;
}

ActList* ReverseList3(ActList* head) 
{ 
    ActList* p; 
    ActList* q; 
    p=head->next; 
    while(p->next!=NULL){ 
        q=p->next; 
        p->next=q->next; 
        q->next=head->next; 
        head->next=q; 
    } 
 
    p->next=head;//相当于成环 
    head=p->next->next;//新head变为原head的next 
    p->next->next=NULL;//断掉环 
    return head;   
}

/*思路：两个人赛跑，如果A的速度是B的两倍的话，当A到终点的时候，B应该刚到中点*/

LinkList* findMidlist(LinkList* head)
{
    LinkList *speed, *speed2;
    
    if (head == NULL || head->next == NULL)
    {
        return head;
    }
    speed = speed2 = head;
    while (1)
    {
        if (speed2->next != NULL && speed2->next->next != NULL)
        {
            speed2 = speed2->next->next;
            speed = speed->next;
        }
        else
        {
            break;
        }
    }
    
    return speed;

/*思路：就像两个人在操场上跑步一样，只要有个人的速度比另一个人的速度快一点，他们肯定会有相遇的时候的*/

int isLooplist (LinkList *head)
{
    LinkList *speed1, *speed2;
    speed1 = speed2 = head;

    if (head == NULL || head->next == NULL)
    {
        return 0;
    }

    while (speed2->next != NULL && speed2->next->next != NULL)
    {
        speed1 = speed1->next;
        speed2 = speed2->next->next;
        if (speed1 == speed2)
        {
            return 1;
        }
    }

    return 0;
}

#include <iostream>

using namespace std;

char *getMemery(void)
{
    char p[]="hello world!";

    return p;
}

int main()
{
    char *str;

    str=getMemery();

    cout<<str;

    return 0;
}

答案：可能是乱码，也有可能是正常输出。因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是NULL，但其原来的内容已经被清除，新内容不可知。

#include <iostream>

using namespace std;

void change(int *a,int &b, int c)
{
    c=*a;
    b=3;
    *a=2;
}

int main()
{
    int a=1, b=2, c=3;

    change(&a,b,c);

    cout<<a<<","<<b<<","<<c<<endl;

    return 0;
}

答案：2，3，3

提示：b是传的值。但是函数体内，做了·个b的引用＆b，修改了函数体内b的值，就是修改b本身。举个形象的例子而言，比如说b是一个人，叫土富贵，把这个名字传进函数体，函数首先给王富贵取了个别名叫王二，然后给王二发了500块钱，这也就相当于给土富贵发了500块钱。

int main()
{
    int *ptr;
    ptr=(int *)0x8000;
    *ptr=0xaabb;

    return 0;
}

答案：这样做可能会导致运行时错误，因为这种做法会给一个指针分配·个随意的地址，这是非常危险的。不管这个指针有没有被使用过，这么做都是不允许的。

答案：
void (*f)()
void* f()
const int* p
int* const p 
const int* const p

int a[9];
int *p=a;

答案：C

提示：解析：数组名a作为代表数组的首地址，是一个常量指针，既然是常量当然是不容修改的，所以a++是错误的。

static int a[3][3]={0,1,2,3,4,5,6,7,8},y,x,*p=&a[2][2];

for(x=0; x<3; x++)
    y+=*(p-x*4);

cout<<y<<endl;

答案：12

提示：8+4+0＝12

A.int (*ptr)[]     B.int* ptr[]
C.int* (Ptr[])     D.int ptr[]

答案：A

答案：

当delete一个指针的时候，实际上仅是让编译器释放内存，但指针本身依然存在。这时它就是一个迷途指针。当使用以下语句时，可以把迷途指针改为空指针：
myPtr二O:
通常，如果在删除一个指针后又把它删除了一次，程序就会变得非常不稳定，任何情况都有可能发生。但是如果你只是删除了一个空指针，则什么事都不会发生，这样做非常安全。
使用迷途指针或空指针是非法的，而且有可能造成程序崩溃。如果指针是空指针，尽管同样是崩溃，但它同迷途指针造成的崩溃相比是一种可预料的崩溃。这样调试起来会方便得多。

答案：

malloc与free是C++/C语占的标准库函数，new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言，光用malloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free

因此C十＋语言需要一个能完成动态内存分配和初始化上作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。

答案：句柄和指针其实是两个截然不同的概念。

     windows系统用句柄标记系统资源，用句柄隐藏系统的信息。你只要知道有这个东西，然后去调用就行了，它是个32bit的uint。

     指针则标记某个物理内存地址，是不同的概念。

#include <iostream>

using namespace std;

void sum(int n)
{
    static unsigned int s=1;

    if(n==1)
    {
        cout<<s;
    }else{
        s*=n;
        sum(n-1);
    }
}

int main()
{
    int n;

    cin>>n;
    sum(n);

    return 0;
}

int FibonacciSequence(unsigned int n)
{

    if(1==n || 0==n)
    {
        return n;
    }else
    {
        return FibonacciSequence(n-1)+FibonacciSequence(n-2);
    }

}

#include <iostream>
#include <cstring>
#include <cstdlib>

using namespace std;

char test[]="hello";
char *out;
int length;

void foo(char src[],char dst[],int length,int start,int rec)
{
    int i;

    for(i=start; i<length; i++)
    {
        dst[rec]=src[i];
        dst[rec+1]=0;
        cout<<dst<<endl;

        if(i<length-1)
        {
            foo(src,dst,length,i+1,rec+1);
        }
    }
}

int main()
{
    length=strlen(test);
    out=(char*)malloc(sizeof(char)*(length+1));
    foo(test,out,length,0,0);
    free(out);
    return 0;
}

提示：该方法存在重复问题

* 
* .* .
* ..* ..* ..
* ...* ...* ...* ...
* ....* ....* ....* ....* ....
* .....* .....* .....* .....* .....* .....
* ......* ......* ......* ......* ......* ......* ......
* .......* .......* .......* .......* .......* .......* .......* .......

#include <iostream>

using namespace std;

int main()
{
    int i,j,k;

    for(i=0; i<8; i++)
    {
        for(j=i; j>=0; j--)
        {
            cout<<"* ";

            for(k=i-1; k>=0; k--)
            {
                cout<<".";
            }
        }

        cout<<endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

#define N (100)
int main()
{
    int i,j,test[N],count=0;

    for(i=0; i<N; i++)
    {
        test[i]=1;
    }

    for(i=2; i<N; i++)
    {
        if(1==test[i])
        {
            for(j=2*i; j<N; j++)
            {
                if(0==j%i)
                    test[j]=0;
            }
        }
    }

    for(i=2; i<N; i++)
    {
        if(1==test[i])
            count++;
            cout<<i<<"\t";
    }

    cout<<endl<<count<<endl;
}

#include <iostream>
#include <cstring>
using namespace std;

#define M (5)
#define N (5)
int pOut[10];
int m = M;
int n = N;

void FindSum(int m,int n)
{
    if(m<1 || n<1 || (n==1 && m!=1))
    {
        return;
    }
    if(m == n)
    {
        pOut[n] = 1;
        for(int i=1; i<=N; i++)
        {
            if(pOut[i]==1)
            {
                cout<<i<<"\t";
            }
        }
        cout<<endl;
        pOut[n] = 0;
    }
    FindSum(m,n-1);
    pOut[n] = 1;
    FindSum(m-n,n-1);
    pOut[n] = 0;
}

int main()
{
    memset(pOut,0,sizeof(pOut));
    if(m<n)
    {
        n = m;
    }
    FindSum(n,m);
}

#include <iostream>
#include <cmath>
#include <cstdlib>

using namespace std;

#define LOOP (1000)
int main()
{
    int i,count=0;
    int x,y;

    for(i=0; i<LOOP; i++)
    {
        x=rand();
        y=rand();
        if(pow(x,2.0)+pow(y,2.0) < RAND_MAX * RAND_MAX)
            count++;
    }

    cout<<count<<endl;
    return 0;
}

答案：出题者的意思显然就是要求你得出一个大概值，也就是250*3.14就可以了。实际上呢，你只要回答700一800之间都是正确的。

提示：那这个问题就很好解决了，求落点可能性之比，就是求一个l/4圆面积和一个正方形面积之比:1/4*3.14*l000=250*3.14=785

答案：STL代表用一致的方式编程是可能的。实际上，它完全不同于我们过去看到的C++编程，也完全不同于大多数教科书里所描述的方式。STL并不是试图用C++编程，只是试图找到一种正确的方式来处理软件，寻找一种可以表达我的想法的语言而已。换句话说，我知道我想说什么。我能用C++说，我能用Ada说，我能用Scheme说。我可以让自己去适应语言，但我说的东西从本质上和语言无关。

答案：泛型编程是一种基于发现高效算法的最抽象表示的编程方法。也就是说，以算法为起点井寻找能使其工作且有效率工作的最一般的必要条件集。令人惊讶的是，很多不同的算法都需要相同的必要条件集，并且这些必要条件有多种不同的实现方式。类似的事实在数学里也可以看到。大多数不同的定理都依赖于同一套公理，并且对于同样的公理存在多种不同的模型。抽象机制！泛型编程假定有某些基本的法则在支配软件组件的行为，并且基于这些法则有可能设计可互操作的模块，甚至还有可以使用此法则去指导我们的软件设计。STL就是一个泛型编程的例子。C++是我可以实现令人信服的例子的语言。

答案：对象、类和继承。

答案：struct可以有构造函数,唯一不同的就是struct里面默认的访句控制是public,class中默认的访I句控制是private。C+＋中存在struct关键字的唯一意义就是为了让C程序员有个归属感，是为了让C+＋编译器兼容以前用C开发的项目。

A、语句1   B.语句2   C.语句3    D.语句4

struct Test
{
    Test(int){}
    Test(){}
    void fun(){}
};

int main()
{
    Test a(1);  //语句1
    a.fun();    //语句2
    Test b();   //语句3
    b.fun();    //语句4
    return 0;
}

答案：D

class A{
    const int size=0;
};

答案：
class A{
    A(){const int size=0};
};

class A{
    static const int size;
};

答案，虚函数采用一种虚调用的办法。虚调用是一种可以在只有部分信息的情况下L作的机制，特别允许我们调用一个只知道接目而不知道其淮确对象类型的函数。但是如果要创建一个对象，你势必要知道对象的准确类型，因此构造函数不能为虚。

答案：不行，这是因为虚函数是有代价的：由于每个虚函数的对象都必须维护一个v表，因此在使用虚函数的时候都会产生一个系统开销。如果仅是一个很小的类，且不想派生其他类，那么根本没必要使用虚函数。

class String
{
public:
    String(const char *str=NULL);
    String(const String &other);
    ~String(void);
    String & operator = (const String &other);
private:
    char *m_data;
};

String::String(const char *str)
{
    if(NULL==str)
    {
        m_data = new char[1];
        *m_data =‘\0‘;
    }
    else
    {
        int length = strlen(str);
        m_data = new char[length+1];
        strcpy(m_data,str);
    }
}

String::String(const String &other)
{
    int length = strlen(other.m_data);
    m_data = new char[length+1];
    strcpy(m_data,other.m_data);
}

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

String::operator =(const String &other)
{
    if(this==&other)
    {
        return *this;
    }

    delete [] m_data;
    int length=strlen(other.m_data);
    m_data = new char[length+1];
    strcpy(m_data,other.m_data);

    return *this;
}

#include <stdio.h>

int main()
{
    printf("%f\n",5);
    printf("%d\n",5.01);

    return 0;
}

答案：
0.000000
1889785610

#include <stdio.h>

int convert(const char *src)
{
    int dst = 0;

    while(*src)
    {
        dst = dst*2 + (*src++) - ‘0‘;
    }

    return dst;
}

int main()
{
    char src[10];
    char *p = src;

    fscanf(stdin, "%s", src);

    printf("%d\n", convert(p));

    return 0;
}

#include <stdio.h>

int main()
{
    int dec;

    scanf("%d",&dec);
    printf("%x\n",dec);

    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    unsigned short i=0;
    int j=8,p;

    cout<<(p=j<<1)<<endl;
    cout<<(i-=1)<<endl;

    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    unsigned short a=0xABCD;
    unsigned short b;
    unsigned short c, d;

    b = (a<<8)&0xff00;
    c = (a>>8)&0x00ff;
    d = b|c;

    cout<<hex<<d<<endl;

    return 0;
}

答案：
第一个问题：是的。一个例子就是只读的状态寄存器。它是volatile,因为它可能被意想不到地改变；它又是const，因为程序不应该试图去修改它.

第二个问题：是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时.

unsigned int a=0;
unsigned int compzero=0xFFFF;

1、地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;

2、资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源

3、线程是处理器调度的基本单位,但进程不是.

4、二者均可并发执行.

1. 概念不同：
连接是指物理的网络连接
在已建立的连接上，建立客户端与oracle的会话，以后客户端与oracle的交互都在一个会话环境中进行

2. 关系是多对多：
一个连接上可以建立多个会话
一个会话只能允许对应零个或一个连接

3. 概念应用：
oracle的sessions参数决定的是会话数而不是物理连接数。
oracle的临时表中的数据是各会话间隔离的，而与连接概念无关。
jdbc的connection，对oracle是一个会话的概念。

4. 实际应用：
对于隐式连接缓冲，每一个连接上建立一个会话，对于每一个会话都将对应一个dedicated process。
对于OCI连接池，只有物理连接上建立的那个会话才对应一个dedicated process(这里记为DP_A,DP_B)。而其他会话对应一个PSUEDO process.这是一个轻量级process，不计入processes数。

1、truncate 是DDL语句，delete 是DML语句；
2、truncate 速度远快于 delete；
原因是：当我们执行delete操作时所有表数据先被copy到回滚表空间，数据量不同花费时间长短不一。而truncate是直接删除数据不进回滚表空间。
3、接（2）这也就导致了delete数据后我们可以运行rollback进行数据回滚，而truncate则是永久删除不能回滚；
4、truncate 操作不会触发表上的delete触发器，而delete会正常触发；
5、truncate语句不能带where条件意味着只能全部数据删除，而delete可删除部分数据；
6、truncate 操作会重置表的高水位线(High Water Mark)，而delete不会。

答案：
1、第一范式（1NF）无重复的列
2、第二范式（2NF）属性完全依赖于主键 [消除部分子函数依赖]
3、第三范式（3NF）属性不依赖于其它非主属性 [消除传递依赖]

答案：
C++中的基础数据类型分为3种：整数型、浮点型和void型。

char *ptr;

if((ptr=(char*)malloc(0))==NULL)
   printf("get a invalid ptr\n");
else
   printf("get a valid ptr\n");

答案：get a valid ptr

char *ptr;

if(sizeof(ptr=(char*)malloc(0))==4)
   printf("get a invalid ptr\n");
else
   printf("get a valid ptr\n");

则输出：get a invalid ptr

A．数据段    B．代码段    C．堆栈     D．堆    E．不一定，看情况

答案：A,A,C,A,D,A

答案：
1、heap是堆，stack是栈。
2、stack的空间由操作系统自动分配释放，heap上的空间手动分酬释放。
3、stack空间有限，heap是很大的自由存储区
4、C中的malloc函数分配的内存空间即在堆上，C++中对应的是new操作符。
5、程序在编译期对变量和函数分配内存都在栈上进行，且程序运行过程中函数调用时参数的传递也在栈上进行。

答案：平衡二义树是一棵空树或．具有下列特点的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。

当待排序记录的关键字均不相同时，排序结果是唯一的，否则排序结果不唯一。

在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生变化，则称这种排序方法是不稳定的。

注意：排序算法的稳定性是针对所有输人实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。

答案：
1、比较两个关键字的大小。
2、改变指向记录的指针或移动记录本身。

/* 二分查找 */
int Binary_Search(int *a,int n,int key)
{
    int low,high,mid;
    low=1;    /* 定义最低下标为记录首位 */
    high=n;    /* 定义最高下标为记录末位 */
    while(low<=high)
    {
        mid=(low+high)/2;    /* 折半 */
        if (key<a[mid])        /* 若查找值比中值小 */
            high=mid-1;        /* 最高下标调整到中位下标小一位 */
        else if (key>a[mid])/* 若查找值比中值大 */
            low=mid+1;        /* 最低下标调整到中位下标大一位 */
        else
        {
            return mid;        /* 若相等则说明mid即为查找到的位置 */
        }

    }
    return 0;
}

A.quicksort    B.bubblesort    C.mergeoort

答案：B。

提示：排序比较问题。对于已经接近排好序的情况，冒泡法是比较快的。

答案：在记录的存储位置和它的关键字之间建立一个确定的对应关系f，由此，不需要进行比较便可直接取得所查记录。在此，我们称这个对应关系f为哈希（Hash）函数，按这个思想建立的表为哈希表。

答案：Map中的数据存储方式是Hashtable。

     Map和Hashmap的区别是接口和类的区别，List和Map是接口，ArrayList和HashMap分别是它们的实现类。
      HashMap是Hashtable的改进版，主要是以（key,value）来存储对象。

1、不调用C++/C的字符串库函数，请编写函数 strcpy
2、strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？

答案：
1、
char *strcpy(char *strDest, const char *strSrc)
{

    assert(strDest != NULL && strSrc != NULL);
    char *ret = strDest;

    while(‘\0‘ != *strSrc)
    {
        *strDest++ = *strSrc++;
    }

    return ret;
}

2、返回char * 类型，用于链式表达，返回具体值。

int main()
{
    char s[]="123456789";
    char d[]="1234";

    strcpy(d,s);
    printf("%s,%s\n",d,s);

    return 0;
}

答案：123456789,6789

void  *memcpy(void *srcDest, const void *srcSrc, size_t size) 
{
      assert((srcDest != NULL) && (srcSrc != NULL));
    
      char  *Dest = (char *)srcDest;
      
      while(size--) 
         *Dest++ = *srcSrc++;
      
      return  srcDest;
}

void test1()
{
    char a[10];
    char *b="0123456789";

    strcpy(a,b);

    cout<<b<<endl;
}

void test2()
{
    char a[10],b[10];
    int i;

    for(i=0; i<10; i++)
    {
        a[i]=‘a‘;
    }

    strcpy(b,a);

    cout<<b<<endl;
}

void test3(char *b)
{
    char a[10];
    
    if(strlen(b)<=10)
    {
        strcpy(b,a);
    }

    cout<<b<<endl;
}

答案：
void test2()
{
    char a[10],b[10];
    int i;

    for(i=0; i<9; i++)
    {
        a[i]=‘a‘;
    }
    

    a[9]=’\0’;
    strcpy(b,a);

    cout<<b<<endl;
}

提示：字符数组并不要求最后一个字符为‘\0’，是否需要加入’\0‘，完全是由系统需要决定。但是字符数组的初始化要求最后一个字符必须为’\0‘，所以test2虽然能够编译通过，但是会出现运行时错误。类似于char c[5]={‘C‘，‘h’,‘i‘,‘n‘,‘a‘}，这样的定义是错误的。

int main()
{
    char a=256;
    int b=a;

    cout<<b+1<<endl;
    return 0;
}

答案：1

答案：
我们可以对程序功能实施测试（正常测试或反常测试），也可以对边界点进行测试，等等。
(l）输入一个负数看程序做出什么样的判断。
(2）输入一个1~1799的年份看程序的输出结果如何。
(3）输入一个2001以后的年份看程序的输出结果如何。
(4）输入年份1800、2000看程序是否能够做出正确的判断。
(5）输入一个介于1800一2000之间的年份看程序是否能够做出正确的判断。
(6）特殊字符的输入（我把负号放在这里面测试）。
(7）其他特殊功能的输入（如年代自动补位）。
(s）安全性能测试（启动多个test.exe程序）。
(9）部分黑盒测试（各个适用系统的测试）。
(10）画面测试（如果有的话）。

答案：功能性穷举测试对程序是做不到的，符合条件的测试用例举不胜举，进行测试不仪耗费时间和精力，而月，有些等价的测试用例重复进行测试就是多余的了。

答案：最常用的进程间通信的方式有信号，信号量，消息队列，共享内存。

答案：用多进程时每个进程有自己的地址空间（addressspace)，线程则共享地址空间。所有其他区别都是由此而来的：
1、速度：线程产生的速度快，线程间的通信快、切换快等，因为它们在同一个地址空间内。
2、资源利用率：线程的资源利用率比较好也是因为它们在同一个地址空间内。
3、同步问题：线程使用公共变量/内存时·需要使用同步机制，还是因为它们在同一个地址空间内。

答案：两者的区别是：mutex可以用于进程之间互斥，critical section是线程之间的互斥。

答案：

垃圾回收可以有效地防止内存泄露，有效地使用可以使用的内存。
垃圾回收器通常作为一个单独的低级别的线程运行，在不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时地调用垃圾回收器对某个对象或所有对象进行垃圾回收。
回收机制有分代复制垃圾回收、标记垃圾回收和增量垃圾回收。

答案：存储过程是用户定义的一系列SQL语句的集合，涉及特定表或其他对象的任务，用户可以调用存储过程。而函数通常是数据库已定义的方法，它接收参数并返回某种类型的值，并且不涉及特定用户表。

答案：事务是作为一个逻辑单元执行的一系列操作。一个逻辑工作单元必须有4个属性，称为ACID（原子性、一致性、隔离性和持久性）属性，只有这样才能称为一个事务。

答案：事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。

答案：
复制表（只复制结构，源表名：A，新表名：B):
select * into B from A where l=0;
拷贝表（拷贝数据，源表名：A，新表名：B):
3elect * into B from A;
四表联查：
select * from A,B,C,D where 关联条件;

答案：
create table #Temp（字段1 类型，字段2 类型...)

A. +    B. &    C. |    D. ||

答案：A

答案：交换是指转发和过滤帧，是交换机的工作．它在OSI参考模型的第二层。而路由是指网络线路当中非直连的链路，它是路由器的工作，在OSI参考模型的第三层。交换和路由的区别很多。首先，交换是不需要IP的，而路由需要，因为IP就是第三层的协议，第二层需要的是MAC地址；再有，第二层的技术和第二层不一样，第二层可以做VLAN、端口捆绑等，第三层可以做NAT、ACL、QOS等。

VLAN是虚拟局域网的英文缩写，它是二个纯二层的技术，它的特点有三：控制广播，安全，灵活性和可扩展性。

答案：SNMP(Simple Network Managcmen Protocol）即简单网络管理协议，它为网络管理系统提供了底层网络管理的框架。SNMP协议的应用范围非常广泛，诸多种类的网络设备、软件和系统中都有所采用，主要是因为SNMP协议有如下几个特点。

首先，相对于其他种类的网络管理体系或管理协议而言，SNMP易于实现。SNMP的管理协议、MIB及其他相关的体系框架能够在各种不同类型的设备上运行，包括低档的个人电脑到高档的大型主机、服务器
及路由器、交换器等网络设备。一个SNMP管理代理组件在运行时不需要很大的内存空间，因此也就不需要太强的计算能力。SNMP协议一般可以在目标系统中快速开发出来，所以它很容易在面市的新产品或升级的老产品中出现。尽管SNMP协议缺少其他网络管理协议的某些优点，但它设计简单、扩展灵活、易于使用，这些特点大大弥补了SNMP协议应用中的其他不足。

其次，SNMP协议是开放的免费产品。只有经过IETF的标准议程批准（IETF是LAB下设的一个组织），才可以改动SNMP协议。厂商们也可以私下改动SNMP协议，但这样做的结果很可能得不偿失，因为他们必须说服其他厂商和用户支持他们对SNMP协议的非标准改进，而这样做却有悖于他们的初衷。

第三，SNMP协议有很多详细的文档资料（例如RFC，以及其他的一些文章、说明书等），网络业界对这个协议也有着较深入的了解，这些都是SNMP协议进一步发展和改进的基础。

最后，SNMP协议可用于控制各种设备，比如电话系统、环境控制设备，以及其他可接入网络且需要控制的设备等，这些非传统装备都可以使用SNMP协议。