类内部存储的东西：太简洁了----小话c++(5)

于 2012-06-02 11:05:25 发布
阅读量9.7k 收藏 47
点赞数 13
分类专栏： 小话c++ 文章标签： 存储 c++ delete 编译器 class xcode4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxsjabcabc/article/details/7623630
版权

[Mac 10.7.1  Lion  Intel-based  x64  gcc4.2.1  xcode4.2]


想知道一个类内部是什么，没有比知道它存储的数据还更直接的了。


Q： 为什么一个不包含任何成员变量的类的大小不是0？

如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Test
{
public:
    Test()
    {
        std::cout << "Test is called..." << std::endl;
    }
    
    ~Test()
    {
        std::cout << "~Test is called..." << std::endl;
    }
};

int main (int argc, const char * argv[])
{
    COUT_ENDL(sizeof(Test))
    
    return 0;
}

运行结果：

sizeof(Test) is 1

A： 这在于，如果使用Test创建一个对象，那么这个对象的大小如果是0的话，可能造成不同对象具有相同的地址；这可能导致之后的访问出现不明确的状态。所以，一般，编译器会给大小为0的类中自动插入一个字节的大小，具体多大可能取决于编译器。我们能够肯定的是，它一定不是0.


Q： Test类的构造函数占用类对象的空间吗？

A： 根据上面sizeof得到的值，它应该是不占用的。从实际上说，从代码段的角度，它们和c函数中的全局函数没什么不同；只不过如何访问它们可能有限制而已。经过测试，发现如果想直接获取Test类构造函数的地址，赋值给c风格函数指针，编译器总是报错，必须采用指向类成员函数指针的方式才能使用，所以这里无法给出一个很好证明它类似全局函数的例子。


Q： 如果一个类中含有成员变量，可以通过获取此类对象的地址绕开访问权限函数来修改对象内部数据吗？

A： 通过地址来修改数据，c++无法阻止这样的操作，只要它不越界访问。如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
private:
    int _value_one;
    int _value_two;
};

int main (int argc, const char * argv[])
{
    A a(10, 100);
    COUT_ENDL(a.value_one())
    COUT_ENDL(a.value_two())
    
    A *pa = &a;
    *(int *)pa = 11;            // modify a's _value_one
    *((int *)pa + 1) = 111;     // modify a's _value_two
    
    COUT_ENDL(a.value_one())
    COUT_ENDL(a.value_two())
    
    return 0;
}

运行结果： 
a.value_one() is 10
a.value_two() is 100
a.value_one() is 11
a.value_two() is 111

显然，此方法有效，而且根本不用担心所操作对应的成员是否是protected或者private的。而且可以确定的是，对象a中成员_value_one地址为a首地址；_value_two的地址紧挨着成员_value_one.


Q： 如果具备继承体系的类对象，成员如何摆放？

A： 如下示例：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
private:
    int _value_one;
    int _value_two;
};

class A_Ex : public A
{
public:
    A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }
    
    int value_three() const { return _value_three; }
    
private:
    int _value_three;
};

int main (int argc, const char * argv[])
{
    A_Ex a(10, 100, 1000);
    
    A *pa = &a;
    COUT_ENDL(*(int *)pa)            
    COUT_ENDL(*((int *)pa + 1))    
    COUT_ENDL(*((int *)pa + 2))  
    
    return 0;
}

运行结果： 
*(int *)pa is 10
*((int *)pa + 1) is 100
*((int *)pa + 2) is 1000

可以看出，A_Ex类继承A类，它的对象首先存放基类成员信息，接着存放本类成员信息，很简单，很直接。


Q： 如果类中含有虚函数，类大小会发生怎样的变化？

A： 如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
    virtual void show() const { }
    
private:
    int _value_one;
    int _value_two;
};

class A_Ex : public A
{
public:
    A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }
    
    int value_three() const { return _value_three; }
    
private:
    int _value_three;
};

int main (int argc, const char * argv[])
{
    A a(10, 100);
    A_Ex a_ex(97, 98, 99);
    COUT_ENDL(sizeof(A))
    COUT_ENDL(sizeof(A_Ex))
    
    return 0;
}

运行结果(生成32位应用程序)：

sizeof(A) is 12
sizeof(A_Ex) is 16

如果在函数结束前加上断点，并打印变量a和a_ex内部数据，得到如下：

很明显，可以看到，虚表指针占用了对象最初的部分，后面接着是成员变量。


Q： 虚表指针到底在哪里？

A： 根据上面的输出数据，虚表指针保存在对象首地址处。下面将来证明它的存在：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
    virtual void show() const {  std::cout << "show A..." << std::endl; }
    
private:
    int _value_one;
    int _value_two;
};

class A_Ex : public A
{
public:
    A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }
    
    int value_three() const { return _value_three; }
    virtual void show() const { std::cout << "show A_Ex..." << std::endl; }
    
private:
    int _value_three;
};

typedef void (*c_style_show)();

int main (int argc, const char * argv[])
{
    A a(10, 100);
    A_Ex a_ex(97, 98, 99);
    
    int *p_vtable = (int *)&a;  // get the address of a, also the vtable pointer's pointer
    COUT_ENDL(p_vtable)
    int *vtable = (int *)*p_vtable; // dereference to get the vtable pointer
    COUT_ENDL(vtable)
    
    // get the first virtual func addr
    int *firstVirtualFunc = (int *)vtable[0];
    COUT_ENDL(firstVirtualFunc)
    
    // convert it to the c_style func, and call it
    c_style_show show_func = (c_style_show)firstVirtualFunc;
    show_func();
    
    return 0;
}

上面的代码，是要刻意取出虚函数表中第一个函数指针(理论上就会是show函数).

对象a虚表指针以及虚表内部函数指针的关系简图如下：



由上图，可知，show_func将被赋值为A类中的show函数。执行结果如下：

p_vtable is 0xbffff9d8
vtable is 0x2060
firstVirtualFunc is 0x1b50
show A...

同理，可以对a_ex对象进行剖析，找出它的虚表和虚表函数。

其实，从上面的分析，也能间接证明类中的成员函数也可以看成全局函数的特殊形式，只是访问方式有所限制。


Q： 当子类和父类的大小不一致的时候，出现的对象切割，该如何理解？

A： 如果非要将一个较大的对象赋值给较小的对象，而且没有按照特定的转换方式，终究可能会发生数据丢失的问题。如下例子：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
    virtual void show() const {  std::cout << "show A..." << std::endl; }

    
private:
    int _value_one;
    int _value_two;
};

class A_Ex : public A
{
public:
    A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }
    
    int value_three() const { return _value_three; }
    virtual void show() const { std::cout << "show A_Ex..." << std::endl; }
    
private:
    int _value_three;
};


int main (int argc, const char * argv[])
{
    A *pa = new A(10, 100);
    A_Ex *pa_ex = new A_Ex(97, 98, 99);
    
    pa->show();
    pa_ex->show();
    
    *pa = *pa_ex;   // cause slice
    pa->show();
    pa_ex->show();
    
    delete pa_ex;
    delete pa;
    
    return 0;
}

输出结果： 
show A...
show A_Ex...
show A...
show A_Ex...

可以看出，*pa = *pa_ex; 虽然造成了对象切割，但是并没有影响pa对象调用show的结果。调试，具体查看下被切割后的结果：


在两个断点处打印*pa的数据：


可以看出*pa数据确实被对象a_ex的数据替换了，不过也可以看出对象a的虚表指针依然没变，导致了调用show函数没有改变。


Q： 可以改变对象a的虚表指针的值吗？

A： 当然可以。如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class A
{
public:
    A(int value_one, int value_two):_value_one(value_one), _value_two(value_two) { }
    int value_one() const { return _value_one; }
    int value_two() const { return _value_two; }
    
    virtual void show() const {  std::cout << "show A..." << std::endl; }

    A & operator=(const A& a)
    {
        if(this != &a)
        {
            *(int *)this = *(int *)&a;
            _value_one = a._value_one;
            _value_two = a._value_two;
        }
        return *this;
    }
    
private:
    int _value_one;
    int _value_two;
};

class A_Ex : public A
{
public:
    A_Ex(int one, int two, int three):A(one, two), _value_three(three) { }
    
    int value_three() const { return _value_three; }
    virtual void show() const { std::cout << "show A_Ex..." << std::endl; }
    
private:
    int _value_three;
};


int main (int argc, const char * argv[])
{
    A *pa = new A(10, 100);
    A_Ex *pa_ex = new A_Ex(97, 98, 99);
    
    pa->show();
    pa_ex->show();
    
    *pa = *pa_ex;   // cause slice
    pa->show();
    pa_ex->show();
    
    delete pa_ex;
    delete pa;
    
    return 0;
}

类A中增加了重载赋值运算符的函数，且内部将对象首地址的虚表指针更改。

运行结果：

show A...
show A_Ex...
show A_Ex...
show A_Ex...

可以看出，对象a的虚表指针已经被更改。


如此简单直白的对象模型, c++继承了c语言的特点。


xichen

2012-6-2 11:05:41


程序员小迷
关注
专栏目录
博客
语言的副作用
09-24 220
副作用产生于表达式中有至少一处计算，且其中全部或部分计算会影响表达式其他项，这可能产生副作用。编译器的优化很可能凸显副作用。
博客
语言的变量交换
09-24 167
不用第三个变量交换两个变量在面试题或者笔试题中无数次被提到，事实上，有些答案是理论性的，不是准确的。以整型为例，如下对比不同交换方式的差异。
博客
逗号运算符
09-23 314
逗号运算符为了减少多条语句多行的困扰，放在一行，简洁直观，又称"顺序求值运算符"。
博客
万恶的goto关键字
09-23 302
提到goto, 大家一定能想到迪杰斯特拉发表的著名论文goto有害论(Go To Statement Considered Harmful)。正是它推动了结构化程序设计语言的发展。公正地说，goto并非那么可怕，机器码/汇编码本身支持跳转，就是goto的底层形态。计算机程序中条件选择、循环等语句最终依然依靠跳转指令完成，只是高级编程语言不建议用goto, 会造成程序员的困扰。但，机器从来都没困扰过，CPU根据jmp或j*指令的地址改写RIP地址并执行，丝滑无比，从未抱怨过。
博客
语言的循环语句
09-22 335
循环语句一般分为while/for/do-while三种。
博客
不同语言的switch/case语句
09-22 696
多路分支选择switch/case是if/else if/else的好看版本，switch中default语句对应if的else语句。每个case对应汇编代码的label, 编译器插入多条jmp语句实现不同分支跳转.
博客
语言的条件语句
09-21 370
万事都有第二种可能，如果不是，那一定有第三种可能。
博客
语言的复合语句
09-21 470
在函数中可以声明和定义变量，包含多条执行语句，概念上和复合语句类似。事实上，二者在复合语句的概念上几乎没有区别。类定义，用{}包起来，也是复合语句的一种。
博客
逻辑运算符
09-20 495
逻辑运算符返回布尔值，用于判断真假。
博客
语言的模糊匹配
09-20 217
人类经常说”好像“、”黑色衣服的”等等一些模糊的词汇，编程语言同样支持模糊匹配以支援人类的需求。
博客
关系运算符
09-19 254
判断相等或者不等的运算符，一般被称为关系运算符。
博客
一元运算符
09-18 478
二元和三元运算符的运算数和运算符的位置比较固定，一元运算符可能在运算数之前，也可能在之后。这产生一些有趣的形式。
博客
语言的优先级
09-18 771
编译器和解释器会对源代码运算数和不同运算符的组合感到困惑，用优先级解决先算什么后算什么。相同优先级的组合也会让编译器困扰应该先做什么，结合性应运而生。
博客
赋值运算符
09-17 656
赋值是编程语言基本操作，即便如此，赋值运算符也并不唯一。大部分编程语言”=”是赋值，”==”是相等。一个常见的疑问是，赋值运算符”=”和数学的相等是一个符号，这会产生误解吗？
博客
语句结束符
09-17 700
这个话题听起来很简单，但不同编程语言的不同语法产生了五花八门的语句结束符。大部分编程语言以换行或者分号作为结束符，当然要排除有续行符的情况。
博客
语言的新类型
09-16 448
编程语言默认提供的类型显然不能满足人类的需要，定义新类型是高级编程语言必须解决的事情。大部分编程语言提供形如结构体或者类，枚举也是一种简单的新类型。微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。助您在编程路上越走越好！
博客
语言的枚举
09-16 469
微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。助您在编程路上越走越好！
博客
语言的布尔类型
09-15 431
布尔是一位英国数学家，他很好地融合了逻辑运算和数学的关系。为了纪念他，用”布尔”表示逻辑的”真”和”假”。布尔类型最早是Algol 60提出。
博客
32位和64位
09-15 364
一般而言，CPU位数是指CPU最轻松操作的寄存器大小。微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。欢迎关注。助您在编程路上越走越好！
博客
数据的二进制形式
09-14 347
研究数据的二进制形式可深入理解计算机如何存储数据，以此可以优化、改进甚至创造新的存储方法。
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值