• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C++基础知识面试精选100题系列(11-20题)[C++ basics]

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

【原文链接】

http://www.cnblogs.com/hellogiser/p/100-interview-questions-of-cplusplus-basics-11-20.html


 【题目11】

运行下面中的C#代码,输出是什么?

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
namespace StringValueOrReference
{
    
class Program
    {
        
internal static void ValueOrReference(Type type)
        {
            String result = 
"The type " + type.Name;

            
if (type.IsValueType)
                Console.WriteLine(result + 
" is a value type.");
            
else
                Console.WriteLine(result + 
" is a reference type.");
        }

        
internal static void ModifyString(String text)
        {
            text = 
"world";
        }

        
static void Main(string[] args)
        {
            String text = 
"hello";

            ValueOrReference(text.GetType());
            ModifyString(text);

            Console.WriteLine(text);
        }
    }
}

分析

输出两行。第一行是The type String is reference type. 第二行是hello。类型String的定义是public sealed class String {...},既然是class,那么String就是引用类型。在方法ModifyString里,对text赋值一个新的字符串,此时改变的不是原来text的内容,而是把text指向一个新的字符串"world"。由于参数text没有加ref或者out,出了方法之后,text还是指向原来的字符串,因此输出仍然是"hello".


题目12

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

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#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;
}

分析

输出n1是一个随机的数字,n20。在C++中,成员变量的初始化顺序与变量在类型中的申明顺序相同,而与它们在构造函数的初始化列表中的顺序无关。因此在这道题中,会首先初始化n1,而初始n1的参数n2还没有初始化,是一个随机值,因此n1就是一个随机值。初始化n2时,根据参数0对其初始化,故n2=0


 题目13

编译运行下图中的C++代码,结果是什么?(A)编译错误;(B)编译成功,运行时程序崩溃;(C)编译运行正常,输出10。请选择正确答案并分析原因

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#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;
}

分析

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


 题目14

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

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include "stdafx.h"

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);
    
// 4,1,100,4

    
return 0;
}

分析

4, 1, 100, 4pString1是一个指针。在32位机器上,任意指针都占4个字节的空间。*pString1是字符串pString1的第一个字符。一个字符占一个字节。pString2是一个数组,sizeof(pString2)是求数组的大小。这个数组包含100个字符,因此大小是100个字节。而在函数SizeOf中,虽然传入的参数是一个字符数组,当数组作为函数的参数进行传递时,数组就自动退化为同类型的指针。因此size4也是一个指针的大小,为4。


题目15

运行下图中代码,输出的结果是什么?这段代码有什么问题,如何改正

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include "stdafx.h"
#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;
}

/*
A is created.
B is created.
A is deleted.
*/

分析

输出三行,分别是:A is created. B is created. A is deleted。会导致内存泄露,在A的析构函数前加上virtual关键字。

用new创建B时,回调用B的构造函数。在调用B的构造函数的时候,会先调用A的构造函数。因此先输出A is created. B is created.接下来运行delete语句时,会调用析构函数。由于pA被声明成类型A的指针,同时基类A的析构函数没有标上virtual,因此只有A的析构函数被调用到,而不会调用B的析构函数。

由于pA实际上是指向一个B的实例的指针,但在析构的时候只调用了基类A的析构函数,却没有调用B的析构函数,这会导致内存泄露。如果在类型B中创建了一些资源,比如文件句柄、内存等,在这种情况下都得不到释放,从而导致资源泄漏。


 【题目16

运行如下的C++代码,输出是什么?

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
#include "stdafx.h"
#include <iostream>

class A
{
    
public:
    
virtual void Fun(int number = 10)
    {
        std::cout << 
"A::Fun with number " << number;
    }
};

class B: public A
{
    
public:
    
virtual void Fun(int number = 20)
    {
        std::cout << 
"B::Fun with number " << number;
    }
};

int main()
{
    B b;
    A &a = b;
    a.Fun();
}

分析

输出B::Fun with number 10。由于a是一个指向B实例的引用,因此在运行的时候会调用B::Fun。但缺省参数是在编译期决定的。在编译的时候,编译器只知道a是一个类型a的引用,具体指向什么类型在编译期是不能确定的,因此会按照A::Fun的声明把缺省参数number设为10。这一题的关键在于理解确定缺省参数的值是在编译的时候,但确定引用、指针的虚函数调用哪个类型的函数是在运行的时候。


 题目17

运行如下的C代码,输出是什么?

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include "stdafx.h"

char *GetString1()
{
    
char p[] = "Hello World";
    
return p;
}

char *GetString2()
{
    
char *p = "Hello World";
    
return p;
}

int _tmain(int argc, _TCHAR *argv[])
{
    printf(
"GetString1 returns: %s. \n", GetString1());
    printf(
"GetString2 returns: %s. \n", GetString2());

    
return 0;
}

分析

输出两行,第一行GetString1 returns: 后面跟的是一串随机的内容,而第二行GetString2 returns: Hello World. 两个函数的区别在于GetString1中是一个数组,而GetString2中是一个指针。

当运行到GetString1时,p是一个数组,会开辟一块内存,并拷贝"Hello World"初始化该数组。接着返回数组的首地址并退出该函数。由于p是GetString1内的一个局部变量,当运行到这个函数外面的时候,这个数组的内存会被释放掉。因此在_tmain函数里再去访问这个数组的内容时,结果是随机的。当运行到GetString2时,p是一个指针,它指向的是字符串常量区的一个常量字符串。该常量字符串是一个全局的,并不会因为退出函数GetString2而被释放掉。因此在_tmain中仍然根据GetString2返回的地址得到字符串"Hello World"。


 题目18

运行下图中C代码,输出的结果是什么

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include "stdafx.h"

int _tmain(int argc, _TCHAR *argv[])
{
    
char str1[] = "hello world";
    
char str2[] = "hello world";

    
char *str3 = "hello world";
    
char *str4 = "hello world";

    
if(str1 == str2)
        printf(
"str1 and str2 are same.\n");
    
else
        printf(
"str1 and str2 are not same.\n");

    
if(str3 == str4)
        printf(
"str3 and str4 are same.\n");
    
else
        printf(
"str3 and str4 are not same.\n");

    
return 0;
}

分析

输出两行。第一行是str1 and str2 are not same,第二行是str3 and str4 are same。

str1和str2是两个字符串数组。我们会为它们分配两个长度为12个字节的空间,并把"hello world"的内容分别拷贝到数组中去。这是两个初始地址不同的数组,因此比较str1和str2的值,会不相同。str3和str4是两个指针,我们无需为它们分配内存以存储字符串的内容,而只需要把它们指向"hello world“在内存中的地址就可以了。由于"hello world”是常量字符串,它在内存中只有一个拷贝,因此str3和str4指向的是同一个地址。因此比较str3和str4的值,会是相同的。


 题目19

运行下图中的C++代码,打印出的结果是什么?

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include "stdafx.h"

bool Fun1(char *str)
{
    printf(
"%s\n", str);
    
return false;
}

bool Fun2(char *str)
{
    printf(
"%s\n", str);
    
return true;
}

int _tmain(int argc, _TCHAR *argv[])
{
    
bool res1, res2;
    res1 = (Fun1(
"a") && Fun2("b")) || (Fun1("c") || Fun2("d"));
    res2 = (Fun1(
"a") && Fun2("b")) && (Fun1("c") || Fun2("d"));

    
return res1 || res2;
}

分析

打印出4行,分别是acda

C/C++中,与、或运算是从左到右的顺序执行的。在计算rest1时,先计算Fun1(“a”) && Func2(“b”)。首先Func1(“a”)打印出内容为a的一行。由于Fun1(“a”)返回的是false, 无论Func2(“b”)的返回值是true还是falseFun1(“a”) && Func2(“b”)的结果都是false。由于Func2(“b”)的结果无关重要,因此Func2(“b”)会略去而不做计算。接下来计算Fun1(“c”) || Func2(“d”),分别打印出内容cd的两行。

在计算rest2时,首先Func1(“a”)打印出内容为a的一行。由于Func1(“a”)返回false,和前面一样的道理,Func2(“b”)会略去不做计算。由于Fun1(“a”) && Func2(“b”)的结果是false,不管Fun1(“c”) && Func2(“d”)的结果是什么,整个表达式得到的结果都是false,因此Fun1(“c”) && Func2(“d”)都将被忽略。


 题目20

运行下面的C++代码,打印的结果是什么?

 

 C# Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include "stdafx.h"
#include <iostream>
using namespace std;

class Base
{
    
public:
    
void print()
    {
        doPrint();
    }

    
private:
    
virtual void doPrint()
    {
        cout << 
"Base::doPrint" << endl;
    }
};

class Derived : public Base
{
    
private:
    
virtual void doPrint()
    {
        cout << 
"Derived::doPrint" << endl;
    }
};

int _tmain(int argc, _TCHAR *argv[])
{
    Base b;
    b.print();

    Derived d;
    d.print();

    
return 0;
}

分析

输出两行,分别是Base::doPrint和Derived::doPrint。在print中调用doPrint时,doPrint()的写法和this->doPrint()是等价的,因此将根据实际的类型调用对应的doPrint。所以结果是分别调用的是Base::doPrint和Derived::doPrint2。如果感兴趣,可以查看一下汇编代码,就能看出来调用doPrint是从虚函数表中得到函数地址的。


【参考】

http://zhedahht.blog.163.com/blog/static/2541117420111169592105/

http://zhedahht.blog.163.com/blog/static/254111742011299219769/

http://zhedahht.blog.163.com/blog/static/25411174201171214133316/

【原文链接】

http://www.cnblogs.com/hellogiser/p/100-interview-questions-of-cplusplus-basics-11-20.html


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C#反射机制发布时间:2022-07-13
下一篇:
未能从程序集“System.ServiceModel,Version=3.0.0.0,Culture=neutral,PublicKeyToken ...发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap