练习（六）

最新推荐文章于 2021-10-15 15:56:13 发布

HySmiley

最新推荐文章于 2021-10-15 15:56:13 发布

阅读量1.3k

点赞数

分类专栏： C/C++ # C++ 文章标签： IT题集

本文链接：https://blog.csdn.net/m0_37264397/article/details/76651958

版权

C/C++ 同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

C++

26 篇文章 0 订阅

订阅专栏

1、链接：https://www.nowcoder.com/questionTerminal/2bae2bca15904cde960a4411bd84018b
来源：牛客网

以下程序的输出结果为（）

#include <string.h>

#include <stdio.h>

void main()

{

char x[] = "STRING";

x[0] = 0;

x[1] = '\0';

x[2] = '0';

printf("%d %d\n", sizeof(x), strlen(x));

}

```
6 1
```
```
7 0
```
```
6 3
```
```
7 1
```

2、链接：https://www.nowcoder.com/questionTerminal/57a149c65e304b839dd302cafd9ef4f0
来源：牛客网

求下面函数的返回值。

 
        int 
         func(x) 
       
        { 
       
        int 
        countx = 0;     
       
        while 
        (x) 
       
        { 
       
        countx ++; 
       
        x = x & (x - 1); 
       
        } 
       
        return 
        countx; 
       
        }

假定x = 9999。

```
8
```
```
1
```
```
100
```
```
其他
```

3、在C++，下列哪一个可以做为对象继承之间的转换()

```
static_cast
```
```
reinterpret_cast
```
```
dynamic_cast
```
```
const_cast
```

4、链接：https://www.nowcoder.com/questionTerminal/5e55c5b7eef5483eba6387551a2f3211
来源：牛客网

若有定义

上述定义中a的类型与下面选项中完全相同的是?

```
char a [ 10 ] ;
```
```
char ( *a) [ 10 ] ;
```
```
char * a ;
```
```
char *a [ 10 ] ;
```

5、下述有关虚函数和纯虚函数说法错误的是？

被virtual关键字修饰的成员函数，就是虚函数

在基类中实现纯虚函数的方法是在函数原型后加“=0” virtual void funtion1()=0

同时含有纯虚拟函数的类称为抽象类，它可以被实例化，但是对象不可以调用纯虚函数

使用纯虚函数的意义是在很多情况下，基类本身生成对象是不合情理的

6、

链接：https://www.nowcoder.com/questionTerminal/a9bfa4f121304f93ad88cfeb0734784b
来源：牛客网

有如下类定义：

 
        class 
         A 
       
        { 
       
        public 
        : 
       
        int 
        fun1(); 
       
        virtual 
        void 
        fun2(); 
       
        private 
        : 
       
        int 
        _a; 
       
        };

在32位机器上，请问sizeof(A)的值为：

```
12
```
```
8
```
```
4
```
```
1
```

7、链接： https://www.nowcoder.com/questionTerminal/e53dcb3afac04f89afc74b281659a1c8
来源：牛客网

有以下程序

 
        #include <stdio. h> 
       
 
        void  
        fun (  
        int  
        *s) 
       
 
        { 
       
 
             
        static  
        int  
        j =  
        0 
        ; 
       
 
             
        do  
        { 
       
 
                 
        s[j] + = s[j+ 
        1 
        ]; 
       
 
             
        } 
        while 
        (+ + j <  
        2 
        ); 
       
 
        } 
       
 
        main() 
       
 
        {  
       
 
             
        int  
        i , a[ 
        10 
        ]={ 
        1 
        , 
        2 
        , 
        3 
        , 
        4 
        , 
        5 
        }; 
       
 
             
        for 
        ( i =  
        1 
        ; i <  
        3 
        ; i + + ) fun( a ); 
       
 
             
        for 
        ( i =  
        1 
        ; i <  
        5 
        ; i + +)printf( 
        "%d" 
        ,a[i]); 
       
 
             
        printf( 
        "\n" 
        ); 
       
 
        } 
       

程序运行后的输出结果是？

```
34756
```
```
5745
```
```
5795
```
```
35745
```

8、链接：https://www.nowcoder.com/questionTerminal/76d0246f449348a29521c1980f91b3a1
来源：牛客网

[不定项选择题]

有如下类定义：

class Foo {

public:Foo(int x):value(x){}//①

~Foo{}//②

private:Foo(){}//③

int value=0;//④

错误的是（）

```
①
```
```
②
```
```
③
```
```
④
```

9、

[不定项选择题]

C++类体系中，不能被派生类继承的有?

```
构造函数
```
```
静态成员函数
```
```
非静态成员函数
```
```
赋值操作函数
```

10、链接：https://www.nowcoder.com/questionTerminal/2de46ad9871c486ead2c3c38c7f1dec1
来源：牛客网

[不定项选择题]

在C++STL中常用的容器和类型，下面哪些支持下标"[]"运算？

```
vector
```
```
list
```
```
deque
```
```
map
```
```
set
```
```
unordered_map
```
```
unordered_set
```
```
stack
```
```
string
```

11、链接：https://www.nowcoder.com/questionTerminal/81a0e8b5838f4a59b4cbbefe4b884f0f
来源：牛客网

[单选题]

以下叙述中正确的是( )

在C++中数据封装是通过各种类型来实现的

在C++中，数据封装可以由struct关键字提供

数据封装就是使用结构类型将数据代码连接在一起

数据封装以后，仍然可以不通过使用函数就能直接存取数据

12、以下叙述中正确的是（）

基类型不同的指针变量可以相互混用

函数的类型不能是指针类型

函数的形参类型不能是指针类型

设有指针变量为 double *p，则 p+1 将指针p移动8个字节

13、下列给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标，作为函数值返回，并把其串长放在形参n所指的变量中。ss所指字符串数数组中共有M个字符串，且串长小于N。
请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。

试题程序。

 
        #define M  
        5 
       
        #define N  
        20 
       
        int 
        fun( 
        char 
        (* ss)[N],  
        int 
        *n) 
       
        { 
       
        int 
        i, k =  
        0 
        , len = N; 
       
        for 
        (i =  
        0 
        ; i < ______; i++) 
       
        { 
       
        len = strlen(ss[i]); 
       
        if 
        (i ==  
        0 
        ) 
       
        *n = len; 
       
        if 
        (len ____ * n) 
       
        { 
       
        *n = len; 
       
        k = i; 
       
        } 
       
        } 
       
        return 
        ( _____ ); 
       
        } 
       
        main( ) 
       
        { 
       
        char 
        ss[M][N] = { 
        "shanghai" 
        ,  
        "guangzhou" 
        ,  
        "beijing" 
        ,  
        "tianjing" 
        ,  
        "chongqing" 
        }; 
       
        int 
        n, k, i; 
       
        printf( 
        "\nThe originalb stringsare:\n" 
        ); 
       
        for 
        (i =  
        0 
        ; i < M; i++) 
       
        puts(ss[i]); 
       
        k = fun(ss, &n); 
       
        printf( 
        "\nThe length of shortest string is: % d\n" 
        , n); 
       
        printf( 
        "\nThe shortest string is: % s\n" 
        , ss[k]); 
       
        }

```
N，< ，k
```
```
N， >，k
```
```
M，<，k
```

M，>，k

14、
链接：https://www.nowcoder.com/questionTerminal/91fc523a89634537bec42503c23bbe5f
来源：牛客网

[单选题]

有以下程序

 
           #include < stdio.h > 
          
           main( ) 
          
           { 
          
           char  
           a[ 
           5 
           ][ 
           10 
           ] ={  
           "one" 
           ,  
           "two" 
           ,  
           "three" 
           ,  
           "four" 
           ,  
           "five" 
           }; 
          
           int  
           i,j; 
          
           char  
           t;  
          
           for  
           ( i= 
           0 
           ;i< 
           2 
           ;i++) 
          
           for  
           ( j=i+ 
           1 
           ;j< 
           5 
           ;j++ ) 
          
           if  
           ( a[i][ 
           0 
           ] >a [j][ 
           0 
           ] ) 
          
           { 
          
           t =a[i][ 
           0 
           ]; 
          
           a[i][ 
           0 
           ] =a[j][ 
           0 
           ]; 
          
           a[j][ 
           0 
           ] =t; 
          
           } 
          
           puts(a[ 
           1 
           ]); 
          
           }

程序运行后的输出结果是？

```
owo
```
```
fwo
```
```
two
```
```
fix
```

15、

链接：https://www.nowcoder.com/questionTerminal/7ca2e2dc2bbb47ccaf1846ae72dc4eab
来源：牛客网

[单选题]

有以下程序

 
           #include <stdio.h> 
          
           void  
           fun (  
           char  
           *p, 
           int  
           n )   
          
           { 
          
           char  
           b [ 
           6 
           ] ＝  
           "abcde" 
           ;  
           int  
           i; 
          
           for  
           ( i ＝  
           0 
           ,p ＝ b;i < n;i + + )  
          
           p [i] ＝ b [i]; 
          
           } 
          
           main( ) 
          
           { 
          
           char  
           a [ 
           6 
           ] ＝  
           "ABCDE" 
           ; 
          
           fun (a, 
           5 
           );  
          
           printf ( 
           "%s\n" 
           ,a ) ; 
          
           ｝

程序运行后的输出结果是？

```
abcde
```
```
ABCDE
```
```
edcba
```
```
EDCBA
```

16、

[单选题]

运行以下 C 语言代码，输出的结果是（）

```
stra strb strc
```
```
stra tra ra
```
```
s s s
```
```
s t r
```

17、
链接：https://www.nowcoder.com/questionTerminal/fe96501afbc543c9a8b2c760fc5ce503
来源：牛客网

STL中的unordered_map和priority_queue使用的底层数据结构分别是什么?()

```
rbtree,queue
```
```
hashtable,heap
```
```
rbtree,heap
```
```
hashtable,queue
```

18、

[单选题]

如下代码段，哪种描述是正确的（）

```
全部正确
```
```
2错，1,3正确
```
```
1,2错，3正确
```
```
1正确，2,3,错
```

19、链接：https://www.nowcoder.com/questionTerminal/32847b5bd1b848388c2338a0a6eb4bd6
来源：牛客网

[不定项选择题]

在 C 语言中下面那个语句的结果是 1 ？

```
main 函数正常结束的返回值
```
```
return 7&1;
```
```
char *p="hello"; return p == "hello";
```
```
上面都不对
```

20、链接：https://www.nowcoder.com/questionTerminal/0d36577768714dec836376322ba061ed
来源：牛客网

[单选题]

下列代码的输出为：

 
           class 
            CParent  
          
           { 
          
           public 
           : virtual 
           void 
           Intro() 
          
           { 
          
           printf( 
           "I'm a Parent, " 
           ); Hobby(); 
          
           } 
          
           virtual 
           void 
           Hobby() 
          
           { 
          
           printf( 
           "I like football!" 
           ); 
          
           } 
          
           };  
          
           class 
            CChild :  
           public 
            CParent {  
          
           public 
           : virtual 
           void 
           Intro() 
          
           { 
          
           printf( 
           "I'm a Child, " 
           ); Hobby(); 
          
           } 
          
           virtual 
           void 
           Hobby() 
          
           { 
          
           printf( 
           "I like basketball!\n" 
           ); 
          
           } 
          
           };  
          
           int 
            main(  
           void 
           ) 
          
           { 
          
           CChild *pChild = 
           new 
           CChild();  
          
           CParent *pParent = (CParent *) pChild;  
          
           pParent->Intro();  
          
           return 
           ( 
           0 
           ); 
          
           }

```
I'm a Parent， I like football!
```
```
I'm a Parent， I like basketball!
```
```
I'm a Child， I like basketball!
```
```
I'm a Child， I like football!
```

21、链接：https://www.nowcoder.com/questionTerminal/1c1b231d01994bdca15ca85564c10668
来源：牛客网

[单选题]

下面描述正确的是

p1和p2申请的空间里面的值都是随机值

p1和p2申请的空间里的值都已经初始化

p1申请的空间里的值是随机值，p2申请的空间里的值已经初始化

p1申请的空间里的值已经初始化，p2申请的空间里的值是随机值

解析：

1、1. sizeof()是运算符，其值在编译时就计算好了，获得的是所建立的最大对象的字节大小，返回值与对象存储的内容没有关系。
2. strlen()是函数，其值需在运行时才能计算出，参数必须是(char*),返回的是字符串的长度，从代表该字符串的第一个地址开始遍历，知道遇到结束符NULL，返回长度不包括NULL。结束标志：x[i]=0; x[i]='\0'。

x[0] = 0;

x[1] = '\0';

x[2] = '0';

三者作用一样，都是c语言风格的字符串的结尾标志

2、

x&(x-1) 求的是二进制中1的个数

x|(x+1) 求的是二进制中0的个数

3、

链接：https://www.nowcoder.com/questionTerminal/a00aa56e4819416f88e7b13a86df6e3a
来源：牛客网

reinterpret_cast：一个指针转化为其他类型的指针时，不做类型检测，操作结果是一个指针指向另一个指针的值的二进制拷贝；

static_cast：允许执行隐式转换和相反的转换操作，父类转换为子类是强制转换Son *son=static_cast(father)，而子类转换为父类就是隐式转换；

dynamic_cast：用于对象的指针和引用，当用于多态类型转换时，允许隐式转换及相反的过程中，与static_cast的不同之处在于，在相反的转换过程中，dynamic_cast会检测操作的有效性，如果返回的不是被请求的有效完整对象，则返回null，反之返回这个有效的对象，如果是引用返回无效时则会抛出bad_cast异常；

const_cast：这个转换操作会操纵传递对象的const属性，或者设置或者移除该属性。

4、

链接：https://www.nowcoder.com/questionTerminal/5e55c5b7eef5483eba6387551a2f3211
来源：牛客网

typedef char T[10] ;

T * a ;

这里T是什么类型呢，把名字抹去不就是类型了吗？ char [10]，T为一个 char 数组。

那么T * a中啊为什么类型呢，T * ，T为数组，是一个整体，a为指向这个数组的一个指针喽。

也就是a为指向一个是个元素的数组的指针。

首先，a是指针，不是数组，然后a是数组指针，不仅仅是指针。所以A，C排除了。那么剩下两项B，D.

char (*a) [10] ;

char *a [10] ;

这里就是一个优先级的问题了，[]优先级要高于解引用运算符。所以第一个a为指针，指向具有十个

char 元素的指针。

第二个为数组，每个元素都是指针，每个指针指向一个 char 变量。

这就是函数指针和函数也有类似的问题。分析优先级即可游刃而解。

5、

链接：https://www.nowcoder.com/questionTerminal/29dbc96dc7ab4e16a369ac71e5a61911
来源：牛客网

virtual void func 加 “=0”，实现虚函数。

抽象类中至少存在一个纯虚函数；存在纯虚函数的类一定是抽象类。存在纯虚函数是成为抽象类的充要条件。

抽象类之所以不能被实例化，是因为它里面是抽象方法，实例化对象调用其里面的方法没有意义，我们需要做的就是覆写掉里面的抽象方法。而这个抽象方法其实就是纯虚函数，通过派生类来override纯虚函数，定义N个方法

6、选B

类的大小只与成员变量（非static数据成员变量）和虚函数指针有关，还要考虑到对齐.

所以类A的大小：4个字节（int _a）+4个字节（指向虚函数的指针）= 8个字节

普通成员函数不算到字节里面，虚函数有一个指向虚函数列表的指针，无论有多少个虚函数都是占用一个字节的大小。

7、

链接：https://www.nowcoder.com/questionTerminal/e53dcb3afac04f89afc74b281659a1c8
来源：牛客网

主要考察static和do while

for( i = 1; i < 3; i + + )将调用两次fun(a)

第一次调用fun(a)时数组的前两个元素变位3、5，此时j=2;

第二次调用fun(a)时，虽然j=2已经不满足++j<2但还是要执行一次，数组第三个元素变为7

然后for循环下标从1开始，所以输出后4个元素。5745

8、C++11的标准新加入了对类内初始值的支持。只要编译器支持新标准，那么第四句应该没有问题吧

9、链接：https://www.nowcoder.com/questionTerminal/9dd60a7827014334866dac44f6652e69
来源：牛客网

答案选A。

      编译器总是根据类型来调用类成员函数。但是一个派生类的指针可以安全地转化为一个基类的指针。这样删除一个基类的指针的时候，C++不管这个指针指向一个基类对象还是一个派生类的对象，调用的都是基类的析构函数而不是派生类的。如果你依赖于派生类的析构函数的代码来释放资源，而没有重载析构函数，那么会有资源泄漏。所以建议的方式是将析构函数声明为虚函数。 
    

      也就是delete a的时候，也会执行派生类的析构函数。 
    

      一个函数一旦声明为虚函数，那么不管你是否加上virtual 修饰符，它在所有派生类中都成为虚函数。但是由于理解明确起见，建议的方式还是加上virtual 修饰符。 
    

      构造方法用来初始化类的对象，与父类的其它成员不同，它不能被子类继承（子类可以继承父类所有的成员变量和成员方法，但不继承父类的构造方法）。因此，在创建子类对象时，为了初始化从父类继承来的数据成员，系统需要调用其父类的构造方法。 
    

      如果没有显式的构造函数，编译器会给一个默认的构造函数，并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 
    

      构造原则如下： 
    

          1. 如果子类没有定义构造方法，则调用父类的无参数的构造方法。 
    

          2. 如果子类定义了构造方法，不论是无参数还是带参数，在创建子类的对象的时候,首先执行父类无参数的构造方法，然后执行自己的构造方法。 
    

          3. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数，则会调用父类的默认无参构造函数。 
    

          4. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类自己提供了无参构造函数，则会调用父类自己的无参构造函数。 
    

          5. 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类只定义了自己的有参构造函数，则会出错（如果父类只有有参数的构造方法，则子类必须显示调用此带参构造方法）。 
    

          6. 如果子类调用父类带参数的构造方法，需要用初始化父类成员对象的方式，比如： 
    

 
         #include <iostream.h> 
        
         class 
          animal 
        
         { 
        
         public 
         : 
        
         animal( 
         int 
         height, 
         int 
         weight) 
        
         { 
        
         cout<< 
         "animal construct" 
         <<endl; 
        
         } 
        
         }; 
        
         class 
          fish: 
         public 
         animal 
        
         { 
        
         public 
         : 
        
         int 
         a; 
        
         fish():animal( 
         400 
         , 
         300 
         ), a( 
         1 
         ) 
        
         { 
        
         cout<< 
         "fish construct" 
         <<endl; 
        
         } 
        
         }; 
        
         void 
          main() 
        
         { 
        
         fish fh; 
        
         }

10、链接：https://www.nowcoder.com/questionTerminal/2de46ad9871c486ead2c3c38c7f1dec1
来源：牛客网

标准 STL 序列容器： vector 、 string 、 deque 和 list 。
标准STL 关联容器： set 、 multiset 、 map 和 multimap 。
非标准序列容器slist 和 rope 。 slist 是一个单向链表， rope 本质上是一 “ 重型 ”string 。
非标准的关联容器hash_set 、 hase_multiset 、 hash_map 和 hash_multimap 。
几种标准的非STL 容器，包括数组、 bitset 、 valarray 、 stack 、 queue 和 priority_queue 。

顺序容器类型
顺序容器
Vector	支持快速随机访问
List	支持快速插入 / 删除
Deque	双端队列
顺序容器适配器
Stack	后进先出（ LIFO ）栈
Queue	先进后出（ FIFO ）队列
Priority_queue	有优先级管理的队列

关联容器类型
Map	关联数组：元素通过键来存储和读取
Set	大小可变的集合，支持通过键实现的快速读取
Multimap	支持同一个键多次出现的 map 类型
Multiset	支持同一个键多次出现的 set 类型

11、

数据封装是一种把数据和操作数据的函数捆绑在一起的机制，C++通过创建类来支持数据封装和数据隐藏

12、

解析】 B 选项中，所谓函数类型是指函数返回值的类型。在Ｃ语言中允许一个函数的返回值是一个指针 ( 即地址 ) ，这种返回指针值的函数称为指针型函数； C 选项中，函数的参数不仅可以是整型、实型、字符型等数据，还可以是指针类型； A 选项中，虽然不同基类型的指针变量占用字节数是相同的 , 但是不能混用。因此 D 选项正确

13、

ss[M][N]为一个二维数组

在fun（）中

M为行数，然后查看每一行的字符长度len。用n记录第一个，作为最小值。

每次比较len与n，若len小于n则更新n，同时记录位置k

循环结束时返回k

14、
定义二维数组一般是类型名 a[ ][ ]{{, , ,},{, , ,}}; 就是有两重花括号。但是，这里定义字符串数组的方式也是正确的。这是二维字符串数组,可以这样看,char a[5][10]={"one","two","three","four","five"}; "one"是 'o':a[0][0], 'n';a[0][1], 'e';a[0][2]。我们把这个看成5行10列的数组的话，第一行的10列元素存放“one”，也就是第一行存了3个元素，后面再一个结束符’\0‘,其他都为空 char a[10]={"abcdefg"} 跟 char a[10]={'a','b','c','d','e','f','g'} 是等价的。

15、

很容易搞错的一道题，函数传递数组时，不是用的数组的副本，而是原数组本身，在本题中，调用函数时，p指向数组a的第一个元素，但在for循环中，有p=b，又把b的地址赋予了p，使p指向b的第一个元素，此时p与a已无关了。。。。。答题时一定要注意题中的陷阱。

16、
p指向str[0],即"stra"的起始地址，在每次打印p后，执行p++，所以输出为stra tra ra

17、

链接：https://www.nowcoder.com/questionTerminal/fe96501afbc543c9a8b2c760fc5ce503
来源：牛客网

map： map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。

unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

18、链接：https://www.nowcoder.com/questionTerminal/eb2802ed655f48c08f1ce9217465d203
来源：牛客网

C++规定不能将A** 转换为const A**（在C语言中是可以的，这个缺陷被C++修正）

我们看看假如允许这种转换，将会发生什么错误

参考代码：

 
         int 
          main()   
        
         {   
        
         const 
         int 
         x = 1;   
        
         int 
         * p;  
        
         int 
         const 
         ** q = &p;  
         //① q为一个指向const int*的指针，现在将其指向non-const int*  p  
        
         *q = &x;             
         // ②现在将q指向的指针赋为常量x的地址（*q即为指针p的地址，这时p指向x） 
        
         //**q=2;             //③报错 
        
         *p = 2;               
         //④因为p是non-const int *,所以可以对其赋值，这时将常量x的值改为了2，明显不符合常识 
        
         printf 
         ( 
         "%d" 
         ,x); 
        
         }

这里的关键在于引入了中间指针p，虽然q本身被const **限制，使得*q是const* ，从而**q不能被修改（见代码④），但是(*q)如果可以是non const*的话（如我们熟悉的const int*可以被赋值为int* ），p=*q是指向non-const的，可以被修改，显然不合理。

而选项3正确的原因在于参数 const A* const*q，说明p指向一个const 指针（*q），这个const 指针再指向const对象。 const 指针本身不能被修改，所以上面代码②会报错。即q指向A**也无影响。

19、

链接：https://www.nowcoder.com/questionTerminal/32847b5bd1b848388c2338a0a6eb4bd6
来源：牛客网

这个考点常考

“hello”存在内存常量区

char *p1 = "hello";char *p2= "hello";

那么p1==p2

但是&p1!=&p2

"hello"整个是地址，只不过cout会把它当字符串输出，这与cout输出p是一样的道理，

p也是地址，但是cout知道他是字符串的首地址，所以认为你想输出的是字符串

cout <<hex<< (int)p <<endl<< (int)("hello") << endl;

这样写，就知道p和"hello"一样，都是地址，而且它们的值相同。

另外一点，这个p指向的字符串不能修改，理由已经说了，这个字符串存在常量区

如果修改会报错。

20、链接：https://www.nowcoder.com/questionTerminal/0d36577768714dec836376322ba061ed
来源：牛客网

CParent *pParent = (CParent *) pChild;

这个是上行转换，即把子类的引用或指针转换为基类表示。这个是安全的。

所以上面的语句的作用是把pChild指针转换为基类指针并赋值给pParent，但是它指向的内容是没变的，所以最终结果是pChild指针和pParent指针都指向了child类。

而且由于基类的方法都已经声明为了虚函数，所以最后pParent->Intro();根据虚函数表就是调用了child类里面的方法。

21、链接：https://www.nowcoder.com/questionTerminal/1c1b231d01994bdca15ca85564c10668
来源：牛客网

在C++primer(第5版)中关于new的讨论有：

1、new当个对象

new在自由空间分配内存，但其无法为其分配的对象命名，因次是无名的，分配之后返回一个指向该对象的指针。

 
         int 
          *pi =  
         new 
         int 
         ;  
         // pi指向一个动态分配的，未初始化的无名对象 
        

此new表达式在自由空间构造一个int类型对象，并返回指向该对象的指针。

默认情况下， 动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值是无定义的，而类类型对象将用默认构造函数进行初始化。

2、new(多个对象)数组

new分配的对象，不管单个对象还是多个对象的分配，都是默认初始化。 但可以对数组进行值初始化，方法就是：在大小之后添加一对空括号。

 
         int 
          *pia =  
         new 
         int 
         [ 
         10 
         ];     
         // 10个未初始化int 
        
 
         int 
          *pia2 =  
         new 
         int 
         [ 
         10 
         ]();  
         // 10个值初始化为0的int 
        