笔试题总结0000-蒲公英云

1.选一个正确的（A）（此题答案不知道是不是正确的，希望各位指正）

A静态链接库不能有同名全局函数
B动态链接库不能有同名全局函数
C两个静态链接库的同名全局函数不能同时加载

D两个动态链接库的同名全局函数不能同时加载

分析：若两个有A.lib，B.lib，两个静态lib文件，并且全部链接，且A有全局函数fun1，fun2，B有fun2，fun3，如果在代码中调用了属于A的函数也调用属于B的函数（可以不是同名的，比如fun1和fun3），那么连接时会发生冲突（fun2）；但是如果只调用了其中一个静态库中的函数，就不会发生冲突，链接器会自动丢掉那个没有被调用过的lib，而且冲突是在编译时不是在运行时。

2.（1）请说明以下局部变量、全局变量和静态变量的区别？
（2）局部变量是否可以和全局变量同名？

（1）：

从作用域看：
全局变量
具有全局作用域，全局变量只需在一个源文件中定义，就可以作用于所有的源文件，当然，在不包含该全局变量定义的源文件需要使用extern关键字再次声明这个全局变量；
静态局部变量
具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有函数可见，而静态句柄变量只对定义它的函数体始终可见；
局部变量
也是局部作用域，它是自动对象(auto)，它在程序运行期间不是一直存在的，而是只在函数执行期间存在，函数的一次调用执行结束后，局部变量被撤销，其所占用的内存也被回收；
静态全局变量
具有全局作用域，它和全局变量的区别在于如果程序包含多个文件的话，它仅作用于定义它的文件中，即被static关键字修饰过的全局变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量，且不会冲突。
从分配内存空间看：

全局变量、静态局部变量、静态全局变量都是在静态存储区中分配空间的；而局部变量是在栈里分配空间的。

（2）局部变量和全局变量可以同名，在函数内引用这个变量时，会优先使用局部变量，而不是全局变量，要明确调用全局变量时，可以在这个变量名前加全局作用符：”::”。

3.请简述链表和数组的区别和优缺点。

1）数组是顺序存储的，元素在内存空间中一般是连续的；而链表元素间则是一种随机的状态，不一定是顺序连续的；

2）数组一旦显式声明后，其大小是固定的，不能动态扩充；而链表可以动态添加节点元素；

3）链表的插入删除操作简单，不需要移动元素的位置，但它不支持索引操作，要访问某个元素需要遍历链表进行查找；数组支持索引操作，可直接定位到第几个元素位置处，但数组的插入和删除操作时间和空间耗费大，一般需要移动元素的位置。

4.请找出下面程序的错误（转载）

#include

struct String

{

     char\* buffer;
     unsigned long size;

};

void resize(String* str, int size)

{

     char \*tempbuffer = new char\[size\];
     if(str->buffer != 0)
     \{ 
               if(size > str->size)
               \{ 
                        size = str->size;
               \}
               for(int i=0; i<size; ++i)
               \{ 
                        tempbuffer\[i\] = str->buffer\[i\];
              \}
     \}
     str->buffer = tempbuffer;
     str->size = size;

}

void copy(String* a, String* b)

{

     resize(a, b->size);
     for(int i=0; i<b->size; ++i)
     \{ 
               a->buffer\[i\] = b->buffer\[i\];
     \}

}

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

{

     String a;
     resize(&a, 3);
     a.buffer\[0\] = 'a';
     a.buffer\[1\] = 'b';
     a.buffer\[2\] = 'c';
     String b;
     copy(&b, &a);
     printf("%s %s", a.buffer, b.buffer);

}

解答：正确的代码如下：

#include

#include //加头文件：#include

struct String

{

     char\* buffer;
     unsigned long size;

};

void resize(String* str, int size)

{

assert(str != NULL); //加一句断言是否为空
     char \*tempbuffer = new char\[size+1\]; //将数组大小再加1，用于存放结束标志’/0’
     if(str->buffer != NULL) //改为标准指针判断非空：!=NULL
     \{ 
               if(size > str->size)
               \{ 
                        str->size = size; //顺序相反了
               \}
               int i; //独立到外面来
               for(i=0; i<size; ++i)
               \{ 
                        tempbuffer\[i\] = str->buffer\[i\];
               \}
               tempbuffer\[i\] = '/0'; //加个字符数组结束符
     \}
     str->buffer = tempbuffer;
     str->size = size;

}

void copy(String* a, String* b)

{

     resize(a, b->size);
     for(int i=0; i<b->size; ++i)
     \{ 
               a->buffer\[i\] = b->buffer\[i\];
     \}

}

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

{

     String a;
     a.buffer = new char\[1\]; //需分配一个空间，后面再调整大小
     resize(&a, 3);
     a.buffer\[0\] = 'a';
     a.buffer\[1\] = 'b';
     a.buffer\[2\] = 'c';
     String b;
     b.buffer = new char\[1\]; //需分配一个空间，后面再调整大小
     copy(&b, &a);
     printf("%s %s", a.buffer, b.buffer);
     return 0; //加个返回值

}

5.makefile文件的作用是什么？

makefile文件保存了编译器和链接器的参数选项，还表述了所有源文件之间的关系（源代码文件需要的特定的包含文件、可执行文件要求包含的目标文件模块及库等）。创建程序make首先读取makefile文件，然后激活编译器、链接器、资源编译器和链接器以便产生最后的输出，最后输出并生成的通常是可执行文件。创建程序make利用内置的推理规则来激活编译器，以便通过对特定cpp文件的编译来产生特定的obj文件。

6.一般析构函数都要写成虚函数，请问为什么要这样做，编程给出实例说明这样做的作用？

先看实例代码：

#include

class ASCEBase

{

public:

ASCEBase()\{\};
virtual ~ASCEBase()\{std::cout<<"ASCEBase destructor!"<<std::endl;\};
virtual void Broadcast()
\{ 
    std::cout<<"See you in another life ASCEBase!"<<std::endl;
\}

};

class ASCEDerive : public ASCEBase

{

public:

ASCEDerive()\{\};
~ASCEDerive()\{std::cout<<"ASCEDerive destructor!"<<std::endl;\}
void Broadcast()
\{ 
    std::cout<<"See you in another life ASCEDerive!"<<std::endl;
\}

};

int main()

{

ASCEBase \*pAsce = new ASCEDerive;
pAsce->Broadcast();
delete pAsce;
system("pause");
return 0;

}

程序运行后输出是：

See you in another life ASCEDerive!

ASCEDerive destructor!

ASCEBase destructor!

这样的程序是正确的，但是，如果将基类ASCEBase析构函数前的virtual去掉，则输出结果是：

See you in another life ASCEDerive!

ASCEBase destructor!

即，派生类ASCEDerive的析构函数并没有被调用！一般情况下类的析构函数中是释放内存资源的代码，这样一来，就很可能造成内存泄漏。

因此，一般将析构函数写出虚函数，是为了当这个类用作基类时，用这个基类指针删除它的派生类的对象时，派生类的析构函数能够被调用到。当然，当一个类不打算作为基类使用时，我们一般不将其声明为虚函数，因为当类里面存在虚函数时，编译器会自动给这个类添加一个虚函数表，里面存放指向虚函数的指针，这无疑会增大类的存储空间。