2016/11/10 反思

struct A
{
 int a;
 short b;
 int c;
 char d;
};
struct B
{
 int a;
 short b;
 char c;
 int d;
};
正确答案: C   你的答案: A

16,16
13,12
16,12
11,16

// 对齐原则：每一成员需对齐为后一成员类型的倍数
// 补齐原则：最终大小补齐为成员类型最大值的倍数
structA
{
 inta;     // 4
 shortb;   // (4) + 2 = 6 下一元素为 int，需对齐为 4 的倍数， 6 + (2) = 8
 intc;     // (8) + 4 = (12)
 chard;    // (12) + 1 = 13， 需补齐为 4 的倍数，13 + (3) = 16
};
structB
{
 inta;     // 4
 shortb;   // (4) + 2 = 6，下一成员为 char 类型，不考虑对齐
 charc;    // (6) + 1 = 7，下一成员为 int 类型，需对其为 4 的倍数，7 + (1) = 8
 intd;     // (8) + 4 = 12，已是 4 的倍数
}

多线程调用时要进行保护时，主要是针对全局变量和静态变量的，函数内的局部变量不会受到影响。
这里i是全局变量，j是局部静态变量，所以 要进行保护。

struct A{
  void foo(){printf("foo");}
  virtual void bar(){printf("bar");}
  A(){bar();}
};
struct B:A{
  void foo(){printf("b_foo");}
  void bar(){printf("b_bar");}
};
那么 
1
2
3
A *p=new B;
p->foo();
p->bar();
输出为：  
正确答案: A   你的答案: B

barfoob_bar
foobarb_bar
barfoob_foo
foobarb_fpp
添加笔记
求解答(10)
已收藏
纠错
本题知识点

C/C++
共有19条讨论 添加解析
37

Ze头像Ze
A *p=newB;// A类指针指向一个实例化对象B， B类继承A类，先调用父类的无参构造函数，bar()输出bar，B类没有自己显示定义的构造函数。
p->foo();//执行B类里的foo()函数，因为foo不是虚函数，所以直接调用父类的foo函数，输出foo
p->bar();//执行B类的bar()函数, 该函数为虚函数，调用子类的实现，输出b_bar

Which of following C++ code is correct?
正确答案: C   你的答案: D

int f() { int *a = new int(3); return *a; }
int *f() { int a[3] = {1, 2, 3}; return a; }
vector<int> f() {vector<int> v(3); return v; }
void f(int *ret) { int a[3] = {1, 2, 3}; ret = a; return; }
添加笔记
已收藏
纠错
本题知识点

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

推荐
Spongicola头像Spongicola
因为C不存在内存泄露的问题且可以得到想要结果，但所有选项都是可以编译通过的，无语法错误。A是内存泄露，没有delete，B数组是临时的，根本传不到主调函数里，D的问题同B一样。

对于选项D,我自己运行了一次

有如下程序段，请问k的值是
1
2
3
4
enum {
    a, b=5, c, d=4, e
} k;
k =c;
正确答案: D   你的答案: 空

3
4
5
6
添加笔记
已收藏
纠错
本题知识点

C/C++  迅雷
参考解析 添加解析
27

推荐
Trenson头像Trenson
enum中：首元素不赋值的话，默认为0；后一个元素不赋值的话比前一个元素大1

#include<stdio.h>
char *myString()
{
    char buffer[6] = {0};
    char *s = "Hello World!";
    for (int i = 0; i < sizeof(buffer) - 1; i++)
    {
        buffer[i] = *(s + i);
    }
    return buffer;
}
int main(int argc, char **argv)
{
    printf("%s\n", myString());
    return 0;
}
正确答案: D   你的答案: A

Hello
Hello World!
Well
以上全部不正确
添加笔记
已收藏
纠错
本题知识点

编程基础  字符串  C/C++
参考解析 添加解析
213

推荐
牛客-007头像牛客-007
答案：D
函数char *myString()中没有使用new或者malloc分配内存，所有buffer数组的内存区域在栈区
随着char *myString()的结束，栈区内存释放，字符数组也就不存在了，所以会产生野指针，输出结果未知

enum string{    
    x1,    
    x2,    
    x3=10,    
    x4,    
    x5,    
} x;
函数外部问x等于什么？
正确答案: C   你的答案: D

5
12
0
随机值
添加笔记
已收藏
纠错
本题知识点

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

推荐
黑风头像黑风
C
在c语言中,这样写法一般是全局变量,程序初始化时会清零

#include<stdio.h>
void main()
{
    short *p,*q;
    short arr[15]={0};
    p=q=arr;
    p++;
    printf("%d,",p-q);
    printf("%d,",(char*)p-(char*)q);
    printf("%d",sizeof(arr)/sizeof(*arr));
}
正确答案: D   你的答案: A

1,0,15
0,2,1
1,1,15
1,2,15
添加笔记
求解答(29)
已收藏
纠错
本题知识点

C/C++
共有18条讨论 添加解析
59

大菜鸟大菜狗头像大菜鸟大菜狗
D
指针自增、自减每次移动的偏移量是指针所指向对象的字节大小，所以p++与q的偏移量是2个字节。
指针相减的值是指针地址的偏移除以指针每次移位的大小；
1)p-q=1;偏移量为2个字节，每次移动2个字节，所以为1
2)(char *)p-(char *)q，指针的偏移没变，但是每次指针移位是按照（char*）类型移动，即每次移动1个字节，所以是2
3）数字每次元素2个字节，所以sizeof(arr)为30，sizeof(*arr)为2。

#include<iostream>
using namespace std;
class B0//基类BO声明
{
public://外部接口
virtual void display()//虚成员函数
{
    cout<<"B0::display0"<<endl;}
};
class B1:public B0//公有派生
{
public:
    void display() { cout<<"B1::display0"<<endl; }
};
class D1: public B1//公有派生
{
public:
    void display(){ cout<<"D1::display0"<<endl; }
};
void fun(B0 ptr)//普通函数
{
    ptr.display();
}
int main()//主函数
{
    B0 b0;//声明基类对象和指针
    B1 b1;//声明派生类对象
    D1 d1;//声明派生类对象
    fun(b0);//调用基类B0函数成员
    fun(b1);//调用派生类B1函数成员
    fun(d1);//调用派生类D1函数成员
}

正确答案: A   你的答案: C

B0::display0 B0::display0 B0::display0
B0::display0 B0::display0 D1::display0
B0::display0 B1::display0 D1::display0
B0::display0 B1::display0 B1::display0


这里使用的不是按地址传递，这样会转化为基类对象，直接调用基类的成员函数，如果是指针传递，改为B0 *ptr，ptr->display()，可以实现多态


虚函数的动态绑定仅在 基类指针或引用绑定派生类对象时发生 ，fun的形参不是指针，所以调用哪个版本的函数编译时就已经确定，根据形参静态类型确定调用B0的成员。