神刀安全网

C++面试题进阶

1.问答题

class ClassA { public:     virtual ~ ClassA(){};     virtual void FunctionA1(){};     void FonctionA2(){}; }; class ClassB { public:     virtual void FunctionB1(){};     void FonctionB2(){}; }; class ClassC : public ClassA,public ClassB { public:     void FunctionA1(){};     void FonctionA2(){};     void FunctionB1(){};     void FonctionB2(){}; };  int main() {     ClassC aObject;     ClassA* pA=&aObject;     ClassB* pB=&aObject;     ClassC* pC=&aObject;     cout<<pA<<endl;     cout<<pB<<endl;     cout<<pC<<endl;      return 0; }

这段代码中pA,pB,pC是否相等,为什么?
答:

C++面试题进阶

pA和pC相等,pB和pC不相等,因为基类ClassA中定义了虚析构函数,运行时会将他直接指向派生类,而ClassB的则会进行一个隐式转换。

2.问答题

class Base {     int m_tag; public:     Base(int tag) : m_tag(tag) {}      void print() {         cout << "Base::print() called" << endl;     }      virtual void vPrint() {         cout << "Base::vPrint() called" << endl;     }      virtual void printTag() {         cout << "Base::m_tag of this instance is: " << m_tag << endl;     } };  class Derived : public Base { public:     Derived(int tag) : Base(tag) {}      void print() {         cout << "Derived::print() called" << endl;     }      virtual void vPrint() {         cout << "Derived::vPrint() called" << endl;     } };  class Derived1 : public Base { public:     Derived1(int tag) : Base(tag) {}      void print() {         cout << "Derived1::print() called" << endl;     }      virtual void vPrint() {         cout << "Derived1::vPrint() called" << endl;     } };  int main(int argc, char *argv[]) {     Derived *foo = new Derived(1);     Base *bar = foo;      foo->print();     foo->vPrint();      bar->print();     bar->vPrint();      Base *ba = new Base(1);     Derived *de = (Derived*)ba;      ba->print();     ba->vPrint();      de->print();     de->vPrint();      return 0; }

这段代码输出是怎样的?
答:

C++面试题进阶

记住一点:普通函数在编译时就确定了,虚函数只有在运行时才确定调用哪个。

3.找错题

试题1:

void test1() {  char string[10];  char* str1 = "0123456789";  strcpy( string, str1 ); }

试题2:

void test2() {  char string[10], str1[10];  int i;  for(i=0; i<10; i++)  {   str1[i] = 'a';  }  strcpy( string, str1 ); }

试题3:

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

答:

  • 试题1字符串str1需要11个字节才能存放下(包括末尾的‘/0’),而string只有10个字节的空间,strcpy会导致数组越界;

  • 试题2中str1循环赋值后没有‘/0’结束,所以在strcpy的时候会产生不确定的结果,这是因为在strcpy中是以‘/0’字符判断字符串是否结束的。

  • 试题3中if(strlen(str1) <= 10)应改为if(strlen(str1) < 10),因为strlen的结果未统计‘/0’所占用的1个字节。

附录:
如何编写一个标准strcpy函数(10分标准)。

//将源字符串加const,表明其为输入参数,加2分 char * strcpy( char *strDest, const char *strSrc ) {   //对源地址和目的地址加非0断言,加3分  assert( (strDest != NULL) && (strSrc != NULL) );  char *address = strDest;  // 基本原理,2分  while( (*strDest++ = * strSrc++) != ‘/0’ );    //为了实现链式操作,将目的地址返回,加3分   return address; }

10分版的strlen函数。

int strlen( const char *str ) //输入参数const {  assert( strt != NULL ); //断言字符串地址非0  int len;  while( (*str++) != '/0' )  {   len++;  }  return len; }

4.找错题

试题4:

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

试题5:

char *GetMemory( void ) {  char p[] = "hello world";  return p; }  void Test( void ) {  char *str = NULL;  str = GetMemory();  printf( str ); }

试题6:

void GetMemory( char **p, int num ) {  *p = (char *) malloc( num ); }  void Test( void ) {  char *str = NULL;  GetMemory( &str, 100 );//应该加上是否申请成功  strcpy( str, "hello" );  printf( str ); }

试题7:

void Test( void ) {  char *str = (char *) malloc( 100 );  strcpy( str, "hello" );  free( str );  ... //省略的其它语句 }

答:

  • 试题4传入中GetMemory( char *p )函数的形参为字符串指针,在函数内部修改形参并不能真正的改变传入形参的值,执行完GetMemory( str )函数后的str仍然为NULL;

  • 试题5的GetMemory函数中的p[]数组为函数内的局部自动变量,在函数返回后,内存已经被释放。

  • 试题6的GetMemory避免了试题4的问题,传入GetMemory的参数为字符串指针的指针,但是在GetMemory中执行申请内存及赋值语句*p = (char *) malloc( num )后未判断内存是否申请成功,应加上:
    if ( *p == NULL )
    {
     …//进行申请内存失败处理
    }
    另外,Test函数中未对malloc的内存进行释放。

  • 试题7存在与试题6同样的问题,在执行char str = (char ) malloc(100);后未进行内存是否申请成功的判断;另外,在free(str)后未置str为空,导致可能变成一个“野”指针,应加上:
    str = NULL;

附录:
看看下面的一段程序有什么错误:

swap( int* p1,int* p2 ) {  int *p;  *p = *p1;  *p1 = *p2;  *p2 = *p; }
  • 在swap函数中,p是一个“野”指针,有可能指向系统区,导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改为:
    swap( int* p1,int* p2 ) {  int p;  p = *p1;  *p1 = *p2;  *p2 = p; }

5.以下为Windows NT下的32位C++程序,请计算sizeof的值。

void Func ( char str[100] ) {  sizeof( str ) = ? }  void *p = malloc( 100 ); sizeof ( p ) = ?

答:
sizeof( str ) = 4
sizeof ( p ) = 4

剖析:

  • Func ( char str[100] )函数中数组名作为函数形参时,在函数体内,数组名失去了本身的内涵,仅仅只是一个指针;在失去其内涵的同时,它还失去了其常量特性,可以作自增、自减等操作,可以被修改。

  • 数组名的本质如下:

    • (1)数组名指代一种数据结构,这种数据结构就是数组;
      例如:

      char str[10]; cout << sizeof(str) << endl; // 输出结果为10,str指代数据结构char[10]。
    • (2)数组名可以转换为指向其指代实体的指针,而且是一个指针常量,不能作自增、自减等操作,不能被修改;

      char str[10]; str++;  //编译出错,提示str不是左值
    • (3)数组名作为函数形参时,沦为普通指针。
      Windows NT 32位平台下,指针的长度(占用内存的大小)为4字节,故sizeof( str ) 、sizeof ( p ) 都为4。

6.编写一个函数,作用是把一个char组成的字符串循环右移n个。

比如原来是“abcdefghi”如果n=2,移位后应该是“hiabcdefgh”。
函数头是这样的:
//pStr是指向以’/0’结尾的字符串的指针
//steps是要求移动的n

void LoopMove ( char * pStr, int steps )
{
 //请填充…
}

答:

// 正确解答1: void LoopMove ( char *pStr, int steps ) {  int n = strlen( pStr ) - steps;  char tmp[MAX_LEN];  strcpy ( tmp, pStr + n );  strcpy ( tmp + steps, pStr);  *( tmp + strlen ( pStr ) ) = '/0';  strcpy( pStr, tmp ); }   // 正确解答2: void LoopMove ( char *pStr, int steps ) {  int n = strlen( pStr ) - steps;  char tmp[MAX_LEN];  memcpy( tmp, pStr + n, steps );  memcpy(pStr + steps, pStr, n );  memcpy(pStr, tmp, steps ); }

7.编写类String的构造函数、析构函数和赋值函数,已知类String的原型为:

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

答:

//普通构造函数 String::String(const char *str) {     if (str == NULL)     {         if (m_data == NULL)             m_data = new char[1]; // 得分点:对空字符串自动申请存放结束标志'/0'的空             //加分点:对m_data加NULL 判断             *m_data = '/0';     }     else     {         int length = strlen(str);         if (m_data == NULL)             m_data = new char[length + 1]; // 若能加 NULL 判断则更好         strcpy(m_data, str);     } }  // String的析构函数 String::~String() {     delete[] m_data; // 或delete m_data;     m_data = NULL; }  //拷贝构造函数 String::String(const String &other) // 得分点:输入参数为const型 {     int length = strlen(other.m_data);     if (m_data == NULL)         m_data = new char[length + 1]; //加分点:对m_data加NULL 判断     strcpy(m_data, other.m_data); }  //赋值函数 String & String::operator = (const String &other) // 得分点:输入参数为const型 {     if (this == &other) //得分点:检查自赋值         return *this;     delete[] m_data; //得分点:释放原有的内存资源     int length = strlen(other.m_data);     if (m_data == NULL)         m_data = new char[length + 1]; //加分点:对m_data加NULL 判断     strcpy(m_data, other.m_data);     return *this; //得分点:返回本对象的引用 }

在这个类中包括了指针类成员变量m_data,当类中包括指针类成员变量时,一定要重载其拷贝构造函数、赋值函数和析构函数,这既是对C++程序员的基本要求,也是《Effective C++》中特别强调的条款。

8.请写一个C函数,若处理器是Big_endian的,则返回0;若是Little_endian的,则返回1

答:

int checkCPU() {  {   union w   {    int a;    char b;   } c;   c.a = 1;   return (c.b == 1);  } }

剖析:嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节, Big-endian 模式的CPU对操作数的存放方式是从高字节到低字节。在弄清楚这个之前要弄清楚这个问题:字节从左到右为从高到低! 假设从地址0x4000开始存放: 0x12345678,是个32位四个字节的数据,最高字节是0x12,最低字节是0x78:在Little-endian模式CPU内存中的存放方式为: (高字节在高地址, 低字节在低地址)

内存地址0x4000 0x4001 0x4002 0x4003

存放内容 0x78 0x56 0x34 0x12

大端机则相反。

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » C++面试题进阶

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址