面试训练海涛54题

最新推荐文章于 2024-11-14 22:14:16 发布

hiphopmattshi

最新推荐文章于 2024-11-14 22:14:16 发布

阅读量796

点赞数

分类专栏：算法学习文章标签：面试 iostream n2 class delete google

本文链接：https://blog.csdn.net/hiphopmattshi/article/details/7930923

版权

算法学习专栏收录该内容

104 篇文章 1 订阅

订阅专栏

运行下图中的C++代码，输出是什么？

#include <iostream>

 

class A

{

private:

        int n1;

        int n2;

public:

        A(): n2(0), n1(n2 + 2)

        {

        }

 

        void Print()

        {

                std::cout << "n1: " << n1 << ", n2: " << n2 << std::endl;

        }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

        A a;

        a.Print();

 

        return 0;

}

类构造函数变量初始化顺序，是按照定义的先后来初始化的

因此

n2(0), n1(n2 + 2)

当然先初始化n1,然后初始化n2. 当然此时n2是一个随机值，所以n1随机值，然后n2为0

题目（13）：编译运行下图中的C++代码，结果是什么？（A）编译错误；（B）编译成功，运行时程序崩溃；（C）编译运行正常，输出10。请选择正确答案并分析原因。

#include <iostream>

 

class A

{

private:

        int value;

 

public:

        A(int n)

        {

                value = n;

        }

 

        A(A other)

        {

                value = other.value;

        }

 

        void Print()

        {

                std::cout << value << std::endl;

        }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

        A a = 10;

        A b = a;

        b.Print();

 

        return 0;

}

没看明白解答，回头看看c++

海涛答案

答案：编译错误。在复制构造函数中传入的参数是A的一个实例。由于是传值，把形参拷贝到实参会调用复制构造函数。因此如果允许复制构造函数传值，那么会形成永无休止的递归并造成栈溢出。因此C++的标准不允许复制构造函数传值参数，而必须是传引用或者常量引用。在Visual Studio和GCC中，都将编译出错。

题目（14）：运行下图中的C++代码，输出是什么？

int SizeOf(char pString[])

{

        return sizeof(pString);

}

 

int _tmain(int argc, _TCHAR* argv[])

{

        char* pString1 = "google";

        int size1 = sizeof(pString1);

        int size2 = sizeof(*pString1);

 

        char pString2[100] = "google";

        int size3 = sizeof(pString2);

        int size4 = SizeOf(pString2);

 

        printf("%d, %d, %d, %d", size1, size2, size3, size4);

 

        return 0;

}

当然sizeof(pString1) 为一个指针当然为4

sizeof(*pString1)实际 *pString1执行第一个字符。当然为1

sizeof(pString2)当然是数组为100

最后一个不清楚，拿不定注意

参看海涛的答案里面说当数组作为函数的参数传递时，数组就退化成为一个指针。当然结果为 4

题目（15）：运行下图中代码，输出的结果是什么？这段代码有什么问题？

#include <iostream>

 

class A

{

public:

        A()

        {

                std::cout << "A is created." << std::endl;

        }

 

        ~A()

        {

                std::cout << "A is deleted." << std::endl;

        }

};

 

class B : public A

{

public:

        B()

        {

                std::cout << "B is created." << std::endl;

        }

 

        ~B()

        {

                std::cout << "B is deleted." << std::endl;

        }

};

int _tmain(int argc, _TCHAR* argv[])
  

{
  

        A* pA = new B();
  

        delete pA;
  

 
  

        return 0;
  

}

B类继承A ，当然先初始化A，然后在初始化B

最后面 delete pA 当然析构的A类。

但是B类没有被析构，因为不是虚函数，A类指针pa当然不能指到B类的析构函数