2016/10/30 C++/C错题

以下一些答案解析转自牛客网牛友的分析，侵删

int a =1,b =32 ;
printf("%d,%d"，a<<b，1<<32);

答案：1，0
执行a<<b时，编译器会先将b与31进行and操作，以限制左移的次数小于等于31。b&31=0，则a<<b=1
执行1<<32时，编译器直接执行算术左移的操作。

char *p="hello"; return p == "hello";
C项：p存的是常量字符串“hello”的地址，p=="hello"的值是1。如果改为char p[ ]="hello",那p=="hello"的值就是0。因为此时p指向了一段（新开辟的）长度为6字节的内存区域，存储的值是“hello”的拷贝（也就是说不是原来的常量字符串）。
如果再修改为char p[ ]="hello"；return（strcmp（p，“hello”））；则又返回1；

如果MyClass为一个类，执行”MyClass a[5], *b[6]”语言会自动调用该类构造函数的次数是()

MyClass a[5]，会创建5个对象，所以会自动调用5次构造函数，但是MyClass *b[6],这不会自动调用构造函数，因为这是声明一个指向6个元素的数组的指针，指针声明的时候是不分配空间的，所以不会调用构造函数，没有指向一个有效的内存空间。

关于引用以下说法错误的是（）。
正确答案: E   你的答案: B (错误)

引用必须初始化，指针不必
引用初始化以后不能被改变，指针可以改变所指的对象
不存在指向空值的引用，但是存在指向空值的指针
一个引用可以看作是某个变量的一个“别名”
引用传值，指针传地址
函数参数可以声明为引用或指针类型




首先，E明显是不对的。引用也是传递的地址，否则你在函数内部操作的就不可能是实参，而只能是形参。实参的内容是不会改变的。其次B项说法不明确，“引用初始化以后不能被改变 ”有歧义。如果已有&a = b; 则不能再有&a = c;  若b = 2; &a = b; a = 5;则是可以的，b的值也将被赋为5。考虑到B项后面又说：“指针可以改变所指的对象 ”，该题考察的应该是前一种意思。综上所诉，选E

在linux下64位c程序，请计算输出的三个sizeof分别是（）

void func(char str_arg[100])
{
     cout<<sizeof(str_arg)<<endl;
}
int main(int argc,char* argv[])
{
     char str[]="Hello";
     char *p=str;
     cout<<sizeof(str)<<endl;
     cout<<sizeof(p)<<endl;
     func("test");
     return 0;
}
答案：6，8，8
sizeof对数组求长度为数组的真实长度，字符串数组的长度要加上最后的'\0'字符。
最后一个：数组作为函数的参数传递时，char str_arg[100]实际为 char *str_arg，传递的是指向数组首元素的指针 sizeof（char *str_arg）=8（64位）

static int a=1;
void fun1(void)
{
    a=2;
}
void fun2(void)
{
    int a=3;
}
void fun3(void)
{
    static int a=4;
}
int main()
{
  printf(“%d”,a);
  fun1( );
  printf(“%d”,a);
  fun2( );
  printf(“%d”，a）；   
  fun3( )
  printf(“%d”,a); 
}
正确答案: B   你的答案: A (错误)

1 2 3 4
1 2 2 2
1 2 2 4
1 1 1 4

首先声明了一个静态全局变量i，首次输出我就不说了，妥妥的1。第二次输出，访问到了早已定义的全局变量i，并改写值，第二次为2。第三次输出，内部定义了一个同名的变量， 它并没有返回值或者被该次执行程序以外任何程序读取a值，所以第三次输出仍然是a。第四次输出，定义了一个静态的局部变量，静态局部变量在函数调用结束后仍然存在，及它的内存空间不会被释放，但其他函数是不能引用它的，所以，两个静态变量虽然同名，但是并不是一样的东西，为2。答案是B

在64位系统中，有如下类：
class C
{
public:
    char a;
    static char b;
    void *p;
    static int *c;
    virtual void func1();
    virtual void func2();
};
那么sizeof（C）的数值是（）
正确答案: D   你的答案: A (错误)

9
17
32
24

应该是D
sizeof（类）计算的是类中存在栈中的变量的大小，而类中的b和*c都是static静态变量，存在全局区中，因此不在计算范围之内，于是只剩下char a，void *p和两个virtual虚函数，a是char类型，占用一个字节，p是指针，在64位系统的指针占用8个字节，而两个虚函数只需要一个虚函数表指针，也是八个字节，加上类中的对齐方式（char a对齐时后面补上7个字节），故答案为24.


虽然大家选的D，但是看分析居然很不一样。。首先需要明确几点：
1 sizeof是用来计算栈大小，不涉及全局区，故类的静态成员大小sizeof不涉及。
2 本题中的虚函数属于同一个类，故只需要一个指针指向虚函数表，所以在64位系统中占用8个字节。就算本题有100个虚函数，那么也只占用8个字节。
综上，占用栈空间的成员有：a, p, func1, func2，由于64位对其，故总空间为8+8+8=24字节。

以下代码有什么问题？

struct Test
 {
     Test( int ) {}
     Test() {}
     void fun() {}
 };
 void main( void )
 {
     Test a(1);
     a.fun();
     Test b();
     b.fun();
 }

正确答案: A   你的答案: C (错误)

b.fun（）会出错
Test结构的定义中应该加上public修饰符，这样才能main函数中调用改类的方法
Test(int){} 应该改成Test(int a){}
以上说法都不正确


Test a(1); //新建了一个对象
a.fun(); //因此可以调用函数
Test b(); //声明了一个函数，并没有新建对象
b.fun(); //没有新建对象，则不能调用函数



A  Test b(); 
 request for member 'fun' in 'b', which is of non-class type 'Test()'
默认构造函数直接写 Test b;就可以


其实Test b();并不会出错，只不过是声明了一个函数b返回类型为Test，但是b.fun（）会出错

void swap_int(int *a,int *b){
  *a=*a+*b;
  *b=*a-*b;
  *a=*a-*b;
}
以下说法正确的是：
结果不正确，因为会溢出，用位与的方式就没问题
结果正确，即使会溢出
结果正确，不会溢出
其他选项都不对

此题可以参考《深入理解计算机》P58页习题2.30
大致思路：即使会产生溢出，但是运算法则仍然成立，举个例子，假设int只有4bit，那么-8 + （-5） = -13（溢出）, 实际结果为3，而3-（-8） = 11（依然溢出），实际结果是-5，
所以，swap程序中的第二句： *b=*a-*b，相当于*b = *a+*b-*b；溢出并没有影响。

下面有关回调函数的说法，错误的是？
正确答案: C   你的答案: 空 (错误)

回调函数就是一个通过函数指针调用的函数
回调函数可能被系统API调用一次，也可能被循环调用多次
回调函数本身可以是全局函数 ，静态函数和某个特定的类的成员函数
回调函数可用于通知机制
添加笔记
收藏
纠错
本题知识点



考察点：this指针

核心就是类成员函数需要this指针访问函数，而全局或者静态函数不需要this指针。
简言之，类的成员函数需要隐含的this指针 而回调函数没有办法提供。

基础概念:
      回调函数就是一个通过函数指针调用的函数。
       如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
       回调函数不是由该函数的实现方法直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。


参考讨论：
http://bbs.youkuaiyun.com/topics/380257801
http://baike.baidu.com/view/414773.htm
编辑于 2015-02-02 15:47:36

类成员函数的重载、覆盖和隐藏区别描述正确的有？
正确答案: C D   你的答案: D (错误)

覆盖是指在同一个类中名字相同，参数不同
重载是指派生类函数覆盖基类函数，函数相同，参数相同，基类函数必须有virtual关键字
派生类函数与基类函数相同，但是参数不同，会"隐藏"父类函数
函数名字相同，参数相同，基类无virtual关键字的派生类的函数会"隐藏"父类函数
添加笔记
收藏
纠错
本题知识点

C/C++  微软
参考解析 添加解析
52

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

分析以下函数，该函数的功能是（）

void sca_from_file(int a[], int n, char fn[])
{
    FILE *fp;
    int i;
    fp = fopen(fn, "r");
    for (i = 0; i < n; i++)
    {
        fscanf(fp, "%d", &a[i]);
    }
    fclose(fp);
}
正确答案: A   你的答案: B (错误)

打开文件fn，从文件中读出n个整数到数组a中
打开文件fn，将数组a的n个元素写到文件中
打开文件fn，从文件中读出n，再读n个整数到数组a中
打开文件fn，将n和数组a的n个元素依次写到文件中
fscanf()作用是从文件流中读取数据，fprintf()是将数据写入到文件。不要搞混。
格式：int fscanf(FILE*stream,constchar*format,[argument...]);
参数：%d：读入一个十进制整数.
%s : 读入一个字符串，遇空字符‘\0'结束。
%c : 读入一个字符。无法读入空值。空格可以被读入。
所以这里是从文件中读出n个整数到数组a中

考虑函数原型void hello(int a,int b=7,char* pszC="*"),下面的函数调用钟,属于不合法调用的是
正确答案: C   你的答案: B (错误)

hello(5)
hello(5,8)
hello(6,"#")
hello(0,0,"#")
添加笔记
收藏
纠错
本题知识点

C/C++  腾讯
参考解析 添加解析
17

推荐
小雨落梧桐头像小雨落梧桐
C.  默认参数 是从 左往右依次赋值.所以C不对.

补充. 1. 默认参数严格遵守从左往右赋值
      2. 在定义函数原型的时候,如果一个参数有默认值,后面一个参数也必须有默认值,比如本题void hello(int a, int b = 7, char *pszC);  这样是不行的,因为 b 的后一个参数没有默认值.
      3.一般把函数的默认参数在函数声明中声明,一般函数声明在.h的头文件里面.如果在函数定义中声明默认参数,那么只能在这个cpp文件中使用. 原因是,你在其它地方使用链接到头文件中并没有关于默认参数的声明
      4.函数重载时候要注意,比如void fun(int a), 重载一个函数void fun(int a, int b = 1);你调用时候写   fun(1); 编译器也不知道你要用哪个,造成混淆.所以要避免这样产生混淆的使用 

两个线程并发执行以下代码，假设a是全局变量，初始为1，那么以下输出______是可能的？
1
2
3
4
void foo(){
    ++a;
    printf("%d ",a);
}
正确答案: A B C D   你的答案: B (错误)

3 2
2 3
3 3
2 2
添加笔记
求解答(45)
收藏
纠错
本题知识点

操作系统  并发  C/C++  阿里巴巴
假设线程x和y同时执行，x和y可随时被抢占，a的初始值为1

A：3, 2
y先执行++a，a为2;
y再执行printf，a入栈，在打印到终端之前切换到x
x执行＋＋a，a为3;
x执行printf，输出3;再切换到y
y执行打印，输出2

B：2 3
x先执行＋＋a，a为2;
x再执行printf，输出2;切换到y
y执行＋＋a，a为3;
y执行printf，输出3;

C：3 3
x先执行＋＋a，a为2;切换到y
y执行＋＋a，a为3;
y执行printf，输出3;切换到x
x执行printf，输出3

D：2 2
类似C，a的初始值为0即可

这里关键有两点：
（1)两个线程可随时被抢占
（2)＋＋a和printf不是原子指令，可随时被打断；特别注意函数printf，a作为参数压栈后，a再变化则不会影响输出（printf实际打印的是压栈的参数，是值拷贝的栈变量）

C语言程序中,运算对象必须是整型数的运算符是？
正确答案: C   你的答案: A (错误)

&&
/
%
*
添加笔记
收藏
纠错
本题知识点

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

推荐
野猪头像野猪
%取余运算是二目运算符,且要求运算对象必须为整数,所以选C。
编辑于 2015-02-03 20:53:37 回复(0)
更多回答(3条)
1

牛客896934号头像牛客896934号
怎么能对一个小数取余呢

C++是否支持嵌套函数定义，如下代码所示？
fun1() { 
    fun2() { 
        fun3() { 
        } 
    }
}
函数可以嵌套调用，但不可以嵌套定义。
这里是三层嵌套，所以不包括内联函数

在重载一个运算符为成员函数时，其参数表中没有任何参数，这说明该运算符是 （ ）。
正确答案: C   你的答案: D (错误)

无操作数的运算符
二元运算符
前缀一元运算符
后缀一元运算符
添加笔记
求解答(10)
收藏
纠错
本题知识点

C/C++
共有3条讨论 添加解析
28

Delia头像Delia
首先可以判断是一元操作符。

因为++和--有前缀和后缀两种形式，为了区分，要求在后缀形式加一个int参数。  const Fraction operator ++(int)   中 int不过是个哑元（dummy）,是永远用不上的，它只是用来判断＋＋是prefix  还是  postfix  。如果有哑元，则是postfix,否则，就是prefix 。 

下面有关c++线程安全，说法错误的是？
正确答案: C   你的答案: A (错误)

线程安全问题都是由全局变量及静态变量引起的
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
c++标准库里面的string保证是线程安全的
POSIX线程标准要求C标准库中的大多数函数具备线程安全性
标准库里面的string在多线程下并不保证是都是安全的，只提供两种安全机制：
1.多个线程同时读取数据是安全的。
2.只有一个线程在写数据是安全的。

对于下面的说法，正确的是____。

对于 struct X { short s; int i; char c; }，sizeof(X) 的值等于 sizeof(s) + sizeof(i) + sizeof(c)
对于某个double变量 a，可以使用 a == 0.0 来判断其是否为零
初始化方式 char a[14] = "Hello, world!"; 和初始化方式 char a[14]; a = "Hello, world!"; 的效果相同
在gcc编译器下，对于 int i = 3; printf("%d %d", ++i, ++i)，运行输出为：4 5
选项A、B、C、D中至少有两个是正确的
以上选项均不正确

选F
A结构体要按高位对齐，int占四个字节，short占两个，char占一个 字节，所以4+4+4=12；
B要判断一个双精度浮点数：if( abs(f) <= 1e-15 )
C数组初始化两种方式：一种逐个赋值 char a[14] ={‘H’，‘e’,'l','l','o'}；另一种 char a[14] = "Hello, world!"

char a[14]; a = "Hello, world!";错误 a为数组首地址是常量不能改变
D 5,5

发表于 2015-09-04 10:58:41回复(0)
6

JNYM
选F,
    对于A，sizeof(X)=4+4+4=12(内存对齐结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐)
    对于B，要判断一个双精度浮点数：if( abs(f) <= 1e-15 )
    对于C，第二种初始化方式是错误的，无法通过编译
    对于D，输出为5，4（从右向左）

“`
在c++中，

const int i = 0;
int j = (int ) &i;
*j = 1;
printf(“%d,%d”, i, *j)

答：0，1
这就是C++中的常量折叠：指const变量（即常量）值放在编译器的符号表中，计算时编译器直接从表中取值，省去了访问内存的时间，从而达到了优化。
而在此基础上加上volatile修改符，即告诉编译器该变量属于易变的，不要对此句进行优化，每次计算时要去内存中取数。
这里也有个小细节：每种编译器对volatile修饰符的修饰作用效果不一致，有的就直接“不理会”
参考：http://blog.youkuaiyun.com/heyabo/article/details/8745942