2016/11/27 C++

题来自牛客网，解析来自牛友，侵删

std::vector::iterator重载了下面哪些运算符？
正确答案: A C D   你的答案: B D (错误)

++
>>
*（前置）
==
添加笔记
求解答(12)
收藏
纠错
本题知识点

C/C++  阿里巴巴
共有8条讨论 添加解析
41

八宝菊花茶头像八宝菊花茶
查了一下：
原题：https://www.nowcoder.com/questionTerminal/c8735c0bed0a4fd18bbd5178e7b641f2

关于重载和多态正确的是
正确答案: B   你的答案: D (错误)

如果父类和子类都有相同的方法,参数个数不同,将子类对象赋给父类后,由于子类继承于父类,所以使用父类指针
调用父类方法时,实际调用的是子类的方法
选项全部都不正确
重载和多态在C++面向对象编程中经常用到的方法,都只在实现子类的方法时才会使用
class A{
    void test(float a){cout<<"1";}
};
class B:public A{
    void test(int b){cout<<"2";}
};
A *a=new A;
B *b=new B;
a=b;
a.test(1.1);
结果是1
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
15

推荐
SunburstRun头像SunburstRun
答案是B
         A调用的是父类的方法,C重载也包含函数重载,D中a.test(1.1)是错误的,应该为(*a).test(1.1);然后在class A里面加public就对了,是这样:
    class A{public: void test(float a){cout<<"1";}
};

编辑于 2015-12-02 17:47:40 回复(4)
更多回答(10条)
34

macrofun头像macrofun
选项D确实不该选，做过之后再来看，选D确实太傻了。
首先，class默认访问权限为private，故所有函数都不能在外部被调用。
其实，即使把函数的访问权限声明为public，也还是不对。通过指针调用函数，应该使用a->test(1.1); 错的离谱。
选D确实不该。
正确答案为B。
编辑于 2015-12-14 10:53:14

dynamic_cast 运用于某种类型的指针或引用时，这种类型必须有虚函数

以下说法正确的是？
正确答案: B D   你的答案: B D (正确)

在多线程中不加限制的随意访问非static局部变量不会导致运算结果出错
在多线程中不加限制的随意访问非static全局变量可能会导致运算结果出错
在多线程中不加限制的随意访问static局部变量不会导致运算结果出错
在多线程中不加限制的随意访问static全局变量可能会导致运算结果出错
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
54

推荐
雷天琪头像雷天琪
无论是static还是非static的全局变量，如果不加限制随意访问的话易出现同步问题。
无论是static还是非static的局部变量，每个线程都是私有的，其他线程不会对其进行干扰。

#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]);
}
程序运行后的输出结果是？
正确答案: B   你的答案: C (错误)

owo
fwo
two
fix
添加笔记
收藏
纠错
本题知识点

C/C++
参考解析 添加解析
3

推荐
Unless Love头像Unless Love
考查二维数组元素的引用。当i为0时,代码处理结果为第一个字符串的第一个字符与第四个字符串的第一个字符调换,当i为1时,代码处理结果为第而个字符串的第一个字符与第五个字符串的第一个字符调换,所以a[1]为fwo。

注：比较的是ASCII码的值

class A
{
public:
    void *p1;
private:
    void *p2;
protected:
    void *p3;
};
class B: public A {};
那么sizeof(B)的数值是（）
正确答案: C   你的答案: C (正确)

8
16
24
32
添加笔记
收藏
纠错
本题知识点

编程基础  C/C++  欢聚时代
参考解析 添加解析
56

推荐
kuring头像kuring
指针在64位系统中占用8个字节，A类中有3个指针，故占用24个字节。B类继承自A类且无成员变量和虚函数表，占用字节和A相同。

选C

多说一点，继承中的父类的私有变量是在子类中存在的，不能访问是编译器的行为，是可以通过指针操作内存来访问的。

const int i = 0; 
int *j = (int *) &i; 
*j = 1; 
printf("%d,%d", i, *j)
输出是多少?
正确答案: A   你的答案: C (错误)

0，1
1，1
1，0
0，0
添加笔记
求解答(41)
收藏
纠错
本题知识点

C/C++
共有23条讨论 添加解析
47

牛客133600号头像牛客133600号
唔，感觉都没有说到重点。这跟编译器的优化编译有关。
C++中的常量折叠：指const变量（即常量）值 放在编译器的符号表中 ，计算时编译器直接从表中取值，省去了访问内存的时间，从而达到了优化。
具体可以看这个：
http://blog.youkuaiyun.com/heyabo/article/details/8745942

class A 
 { 
      int i; 
      union U 
      { 
          char buff[13]; 
          int i; 
      }u; 
      void foo() {    } 
      typedef char* (*f)(void*); 
      enum{red, green, blue} color; 
 }a; 
sizeof(a)的值是（）

正确答案: D   你的答案: D (正确)

20
21
22
24
非以上选项
添加笔记
收藏
纠错
本题知识点

C/C++  阿里巴巴
参考解析 添加解析
7

推荐
墨儿头像墨儿
联合表示若干数据成员取其一，故以叠加方式分配内存，所占字节数为最大数据成员所占的字节数。 还要字节对齐
空函数 不占字节
所以
4+16+0+0+4
编辑于 2015-02-04 18:12:43 回复(0)
更多回答(11条)
26

Alpha.Tan头像Alpha.Tan
答案：D
实例化class A
int i占4个字节
union U实例化为u占取16个字节（char数组占13个字节，但因为最大类型为int，所以占取只能为4字节的整数倍即最小16字节）
空函数不占取字节
未实例化指针不占取字节
枚举类型占取4个字节
总共占取4+16+4=24个字节
编辑于 2015-03-31 22:58:44 回复(5)
9

幸福鸟头像幸福鸟
空函数是不占字节的，还有就是typedef只是一个声明而已，也不占字节；枚举类型是用int型实现的，故占4个字节；联合类型中字节数是12+4（有一位是'\0'）故总共是4+16+4个字节。
答案选D

#include <iostream>
using namespace std;

class A {
    public:
    ~A() {
        cout << "~A()";
    }
};
class B{
    public:
    virtual ~B() {
    cout << "~B()";
}
};
class C: public A, public B {
    public:
    ~C() {
        cout << "~C()";
    }
};
int main() {
    C * c = new C;
    B * b1 = dynamic_cast<B *>(c);
    A * a2 = dynamic_cast<A *>(b1);
    delete a2;
}
则程序输出：
正确答案: D   你的答案: A (错误)

~C()~B()~A()
~C()~A()~B()
A)B)都有可能
以上都不对

main()函数中，第一句只用了new，调用了构造函数，没用delete，不会调用析构函数，内存泄露。第二句、第三句只是定义了指向不同对象的指针，不会产生对象，所以构造函数、析构函数都没调用，最后一句delete调用析构函数，因为基类A的析构函数不是虚函数，所以只调用A的析构函数，输出：~A()，如果A的析构函数加上virtual, 输出：~C()~B()~A()，与直接delete c输出一样。 析构函数声明为虚函数，这样析构时，先调用派生类的析构函数，再调用基类的析构函数，防止内存泄露。

由多个源文件组成的C程序，经过编辑、预处理、编译，链接等阶段会生成最终的可执行程序。下面哪个阶段可以发现被调用的函数未定义？
正确答案: C   你的答案: B (错误)

预处理
编译
链接
执行

编译时只是把函数的符号地址记录下来，链接时该函数符号有定义才会变成具体的地址。如果链接过程中所有符号都有定义，链接成功，生成可执行文件；否则链接失败。

正确答案: E   你的答案: B (错误)

0
4
这取决于主机的字的大小。
8
编译错误或者为1

E，因为没有这个结构体或者实体，无法识别，如果当做void是标记就是1

在C语言中,关于静态变量的说法,正确的有()
正确答案: B   你的答案: D (错误)

静态变量和常量的作用相同
函数中的静态变量,在函数退出后不被释放
静态变量只可以赋值一次,赋值后则不能改变
静态全局变量的作用域为一个程序的所有源文件
添加笔记
求解答(16)
收藏
纠错
本题知识点

C/C++
共有9条讨论 添加解析
14

Hahaha1993头像Hahaha1993
函数中的静态变量是静态局部变量 函数退出后不被释放 在程序运行结束时才释放。只在函数中可访问。
静态全局变量的作用域只能是定义它的文件里，不是被其他文件使用。

int* pint = 0; 
pint += 6; 
cout << pint << endl;
以上程序的运行结果是：
正确答案: C   你的答案: C (正确)

12
72
24
0
6
任意数
添加笔记
求解答(15)
收藏
纠错
本题知识点

C/C++
共有13条讨论 添加解析
42

keviv_li头像keviv_li
第一句的意思是将pint指针指向0地址处，由于指针类型是int，每次加1相当于移动四个字节，（在int为四个字节的机器上）；加上6，地址为0x18
发表于 2016-05-06 10:29:57 回复(6)
6

CiaoLiang头像CiaoLiang
指向地址零加6，int是4位地址，值为24

以下哪个属于在预编译阶段执行____,以下哪些指令属于操作符___
a:malloc;  b:++;  c:#pragma;  d:sizeof;   e:#define
正确答案: C   你的答案: C (正确)

预编译c,e 操作符a,b
预编译c,d 操作符b,e
预编译c,e 操作符b,d
预编译a,d 操作符b,d
添加笔记
求解答(4)
收藏
纠错
本题知识点

C/C++
共有4条讨论 添加解析
10

Blizard223头像Blizard223
带#的肯定是预编译指令了，所以c和e预编译；sizeof为操作符，与+，-，*这一类的一样，不是神马函数，malloc为函数，参数为字节数，返回一个void* 指针。
1
int *p;p = (int*)malloc(sizeof(int) * 128);

int countx=0,x=8421;
while(x){
    countx++;
    x=x&(x-1);
} 
当程序跳出循环后，countx的值为 1 。
你的答案 (错误)

1 5
参考答案 6

 注：这个是我计算错误

java不支持类得多继承

void func(char *p)
{
    p=p+1;
}
int main()
{
    char s[]={'1','2','3','4'};
    func(s);
    printf("%c",*s);
    return 0;
}
以下程序执行后的输出结果为（）
2
编译错误
1
无法确定


我们知道，s中存储的值是一个地址，即数组首元素'1'所在存储单元的地址，执行func函数时，将这个地址值传给p，然后，在函数体中，对p执行加1操作，使p指向数组的第1个元素（从0算起），即s[1]。但是，这只是对p的修改，跟s毫无关系！在传参时，将s的值拷贝给p，之后，s与p就毫无关系了。 func函数结束后，p超出作用域被释放掉了，此时打印s指向的内容（即*s），仍然是s[0]的值，而不是s[1]的值。所以，原题应该选择C。

class A {
...
private:
     int a;
public:
     const int b;
     float* &c;
     static const char* d;
     static double* e;
};
则构造函数中，成员变量一定要通过初始化列表来初始化的是：______。
a b c
b c
b c d e
b c d
b
c
添加笔记
邀请回答
收藏
分享
纠错
10个回答 添加回答
44

推荐
夏雨天
选择B：
构造函数初始化时必须采用初始化列表一共有三种情况，   
1.需要初始化的数据成员是对象(继承时调用基类构造函数)   
2.需要初始化const修饰的类成员   
3.需要初始化引用成员数据
因为static属于类并不属于具体的对象，所以 static成员是不允许在类内初始化的，那么static const 成员是不是在初始化列表中呢？
答案是NO
一是static属于类，它在未实例化的时候就已经存在了，而构造函数的初始化列表，只有在实例化的时候才执行。
二是static成员不属于对象。我们在调用构造函数自然是创建对象，一个跟对象没直接关系的成员要它做什么呢

a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）