首页 > 试题广场 >

在64位系统中,有如下类: class A { public

[单选题]
在64位系统中,有如下类:
class A
{
public:
    void *p1;
private:
    void *p2;
protected:
    void *p3;
};
class B: public A {};
那么sizeof(B)的数值是()
  • 8
  • 12
  • 16
  • 20
  • 24
推荐
指针在64位系统中占用8个字节,A类中有3个指针,故占用24个字节。B类继承自A类且无成员变量和虚函数表,占用字节和A相同。

选C

多说一点,继承中的父类的私有变量是在子类中存在的,不能访问是编译器的行为,是可以通过指针操作内存来访问的。具体例子如下,例子中为了便于打印变量,将变量更改为了int类型:
  #include <iostream>
  
  class A
  {
  public:
      A() : p1(1), p2(2), p3(3) {}
  public:
      int p1; 
  private:
      int p2; 
  protected:
      int p3; 
  };
  
  class B: public A {}; 
  
  int main()
  {
      A a;
      std::cout << *(int *)&a << std::endl;
      std::cout << *((int *)&a + 1) << std::endl;
      std::cout << *((int *)&a + 2) << std::endl;
      B b;
      std::cout << *(int *)&b << std::endl;
      std::cout << *((int *)&b + 1) << std::endl;
      std::cout << *((int *)&b + 2) << std::endl;
  }

编辑于 2015-01-31 11:07:02 回复(9)
linux 32位下的结果,供大家参考: 
#include <stdio.h>                                                                                                                                                   
   class A
  {
      public:
          void *p1;
          int a;
          int b;
       private:
          void *p2;
          int c;
          int d;
      protected:
          void *p3;
          int e;
          int f;
  };
  class B: public A {};
  class C: private A {};
  class D: protected A {};
  
  int main()
  {
      int ret_public = sizeof(B);
      int ret_private = sizeof(C);
      int ret_protected = sizeof(D);
      printf("public_ret = %d\n", ret_public);
      printf("private_ret = %d\n", ret_private);
      printf("protected_ret = %d\n", ret_protected);
      return 0;
  }


编辑于 2016-08-28 17:25:20 回复(0)
            32位系统    64位系统     (单位Bytes)   
char         1                  1
short        2                  2
int            4                  4 
指针         4                  8
long         4                  8
float         4                  4
double     8                  8

发表于 2015-08-29 15:18:35 回复(7)
关键在于继承了全部变量,不过不是都能访问而已!
发表于 2016-02-24 04:12:30 回复(2)
继承的时候都会继承过来,只是部分不能访问
发表于 2016-12-30 21:22:25 回复(0)
指针在32位系统中占4个字节,在64位系统中占8个字节,可以确定选择E选项24符合题意。
发表于 2020-05-22 22:39:45 回复(0)
子类继承父类的私有成员,只不过不能访问。另外可以通过指针操作内存来访问父类的私有成员
发表于 2018-09-14 20:39:11 回复(0)
C
学到了,一直以为private派生后就没有了,原来还在对象内存中啊
发表于 2015-04-09 14:10:26 回复(0)
继承中的父类的私有变量是在子类中存在的,不能访问是编译器的行为,是可以通过指针操作内存来访问的。
发表于 2015-09-07 22:01:10 回复(1)
转发大佬的:
              32位系统    64位系统     (单位Bytes)   
char         1                  1
short        2                  2
int            4                  4 
指针         4                  8
long         4                  8
float         4                  4
double     8                  8
发表于 2024-03-09 19:27:06 回复(0)
答案确定没问题吗?void型指针不是占1个字节吗?什么时候占8个字节了?
发表于 2019-08-09 20:04:51 回复(0)
三个指针,64位中一个指针占8个字节,24
发表于 2019-03-04 19:42:39 回复(0)
64位环境下指针占8个字节。
编辑于 2018-12-03 20:01:06 回复(0)
C
发表于 2018-09-14 08:52:51 回复(0)
Bib头像 Bib
如果有虚函数呢,是不是还要考虑虚函数表
发表于 2018-07-28 12:55:25 回复(0)
继承不论是公有继承还是私有继承保护继承,子类都会包含父类的所有成员,包括私有成员,只是私有成员不能直接访问
发表于 2018-06-14 09:56:20 回复(0)
指针在64位系统中占用8个字
发表于 2017-10-10 12:27:57 回复(0)
眼瞎没看见64位系统...
发表于 2017-09-24 03:29:20 回复(0)
视力下降  64位。。
发表于 2017-07-06 17:44:17 回复(0)
指针在32位系统占4个字节,在64位系统占8个字节
发表于 2017-06-28 22:50:33 回复(0)
64位系统中,一个指针占8个字节。B类继承A类中,public和private的成员变量,B类中还有一个虚表指针。B类敏感词3个指针,sizeof(B)=24
发表于 2017-03-10 20:25:26 回复(0)