经典c++面试题三

2023-07-06   


9. 结构与联合有和区别?
   1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员(所有成员共用一块地址空间), 而结构的所有成员都存在(不同成员的存放地址不同)。
   2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
   10. 下面关于“联合”的题目的输出?
   a)
   #include
   union
  
   int i;
   char x[2];
   a;
   void main()
  
   a.x[0] = 10;
   a.x[1] = 1;
   printf(“%d”,a.i);
  
   答案:266 (低位低地址,高位高地址,内存占用情况是Ox010A)
   b)
   main()
  
   union
   int i;
   struct
   char first;
   char second;
   half;
   number;
   number.i=0×4241;
   printf(“%c%c ”, number.half.first, mumber.half.second);
   number.half.first=’a\;
   number.half.second=’b\;
   printf(“%x ”, number.i);
   getch();
  
   答案: AB (0×41对应’A\,是低位;Ox42对应’B\,是高位)
   6261 (number.i和number.half共用一块地址空间)
  
   11. 已知strcpy的函数原型:char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串,strSrc 是源字符串。不调用C++/C 的字符串库函数,请编写函数 strcpy。
   答案:
   char *strcpy(char *strDest, const char *strSrc)
  
   if ( strDest == NULL || strSrc == NULL)
   return NULL ;
   if ( strDest == strSrc)
   return strDest ;
   char *tempptr = strDest ;
   while( (*strDest++ = *strSrc++) != ‘’)
   ;
   return tempptr ;
  
   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(const char *str)
  
   if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断
  
   m_data = new char[1] ;
   m_data[0] = ‘′ ;
  
   else
  
   m_data = new char[strlen(str) + 1];
   strcpy(m_data,str);
  
  
   String::String(const String &another)
  
   m_data = new char[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 = new char[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 与 #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_H
   int 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_H
   extern “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函数例子工程中包含的三个文件的源代码如下:
   #ifndef C_EXAMPLE_H
   #define C_EXAMPLE_H
   extern int add(int x,int y);
   #endif
   #include “cExample.h”
   int add( int x, int y )
  
   return x + y;
  
   // c++实现文件,调用add:cppFile.cpp
   extern “C”
  
   #include “cExample.h”
  
   int main(int argc, char* argv[])
  
   add(2,3);
   return 0;
  
   如果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_H
   extern “C” int add( int x, int y );
   #endif
   //C++实现文件 cppExample.cpp
   #include “cppExample.h”
   int add( int x, int y )
  
   return x + y;
  
  
   extern int add( int x, int y );
   int main( int argc, char* argv[] )
  
   add( 2, 3 );
   return 0;
  
   15题目的解答请参考《C++中extern “C”含义深层探索》注解:
  
   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. 多态:是将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
   18. 重载(overload)和重写(overried,有的书也叫做“覆盖”)的区别?
   常考的题目。从定义上来说:
   重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。
   重写:是指子类重新定义复类虚函数的方法。
   从实现原理上来说:
   重载:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名 函数:function func(p:integer):integer;和function func(p:string):integer;。那么 编译器做过修饰后的函数名称可能是这样的:int_func、str_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的。也就是说,它 们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!
   重写:和多态真正相关。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚绑定)。


相关内容:

  1. 经典c++面试题二
  2. 经典c++面试题四
  3. 经典C++面试题一
  4. C和C++经典笔试题附答案解析
  5. C++面试题目
  6. 威盛公司软件C++工程师笔试题面试题