0
点赞
收藏
分享

微信扫一扫

C++语言中类与引用感悟之经典


目录

​​1、类中在内存中的定义​​

​​2、C++引用的本质​​

​​3、引用和指针的区别​​

1、类中在内存中的定义

       类是创建对象的模板,不占用内存空间,不存在于编译后的可执行文件中;而对象是实实在在的数据,需要内存来存储。对象被创建时会在栈区或者堆区分配内存。

      直观的认识是,如果创建了 10 个对象,就要分别为这 10 个对象的成员变量和成员函数分配内存,如下图所示:

C++语言中类与引用感悟之经典_#include

       不同对象的成员变量的值可能不同,需要单独分配内存来存储。但是不同对象的成员函数的代码是一样的,上面的内存模型保存了 10 份相同的代码片段,浪费了不少空间,可以将这些代码片段压缩成一份。

      事实上编译器也是这样做的,编译器会将成员变量和成员函数分开存储:分别为每个对象的成员变量分配内存,但是所有对象都共享同一段函数代码。如下图所示:

C++语言中类与引用感悟之经典_#include_02

成员变量在堆区或栈区分配内存,成员函数在代码区分配内存。

代码实现:使用 sizeof 获取对象所占内存的大小:

#include <iostream>
using namespace std;

class Student{
private:
char *m_name;
int m_age;
float m_score;
public:
void setname(char *name);
void setage(int age);
void setscore(float score);
void show();
};

void Student::setname(char *name){
m_name = name;
}
void Student::setage(int age){
m_age = age;
}
void Student::setscore(float score){
m_score = score;
}
void Student::show(){
cout<<m_name<<"的年龄是"<<m_age<<",成绩是"<<m_score<<endl;
}

int main(){
//在栈上创建对象
Student stu;
cout<<sizeof(stu)<<endl;
//在堆上创建对象
Student *pstu = new Student();
cout<<sizeof(*pstu)<<endl;
//类的大小
cout<<sizeof(Student)<<endl;

return 0;
}

运行结果:
12
12
12

     Student 类包含三个成员变量,它们的类型分别是 char *、int、float,都占用 4 个字节的内存,加起来共占用 12 个字节的内存。通过 sizeof 求得的结果等于 12,恰好说明对象所占用的内存仅仅包含了成员变量。

    总结: 类可以看做是一种复杂的数据类型,也可以使用 sizeof 求得该类型的大小。从运行结果可以看出,在计算类这种类型的大小时,只计算了成员变量的大小,并没有把成员函数也包含在内。

      对象的大小只受成员变量的影响,和成员函数没有关系。

     假设 stu 的起始地址为 0X1000,那么该对象的内存分布如下图所示:

C++语言中类与引用感悟之经典_成员变量_03

m_name、m_age、m_score 按照声明的顺序依次排列,和结构体非常类似,也会有内存对齐的问题。

2、C++引用的本质

引用对各位开发者来说,既陌生有熟悉,总是感觉糊里糊涂。先来看下例子如下:

#include <iostream>
using namespace std;

int main(){
int a = 99;
int &r = a;
cout<<a<<", "<<r<<endl;
cout<<&a<<", "<<&r<<endl;

return 0;
}

运行结果:
99, 99
0x28ff44, 0x28ff44

我们知道,变量是要占用内存的,虽然我们称 r 为变量,但是通过​​​&r​​获取到的却不是 r 的地址,而是 a 的地址,这会让我们觉得 r 这个变量不占用独立的内存,它和 a 指代的是同一份内存。

可以继续看下面的这个例子:

#include <iostream>
#include <iomanip>
using namespace std;

int num = 99;

class A{
public:
A();
private:
int n;
int &r;
};

A::A(): n(0), r(num){}

int main (){
A *a = new A();
cout<<sizeof(A)<<endl; //输出A类型的大小
cout<<hex<<showbase<<*((int*)a + 1)<<endl; //输出r本身的内容
cout<<&num<<endl; //输出num变量的地址

return 0;
}

运行结果:
8
0x442000
0x442000

从运行结果可以看出:

第一:成员变量 r 是占用内存的,如果不占用的话,​​sizeof(A)​​的结果应该为 4。

第二:r 存储的内容是​​0x442000​​,也即变量 num 的地址。

总结:这说明 r 的实现和指针非常类似。如果将 r 定义为​​int *​​类型的指针,并在构造函数中让它指向 num,那么 r 占用的内存也是 4 个字节,存储的内容也是 num 的地址。其实引用只是对指针进行了简单的封装,它的底层依然是通过指针实现的,引用占用的内存和指针占用的内存长度一样,在 32 位环境下是 4 个字节,在 64 位环境下是 8 个字节,之所以不能获取引用的地址,是因为编译器进行了内部转换。

3、引用和指针的区别

1) 引用必须在定义时初始化,并且以后也要从一而终,不能再指向其他数据;而指针没有这个限制,指针在定义时不必赋值,以后也能指向任意数据。

2) 可以有 const 指针,但是没有 const 引用。也就是说,引用变量不能定义为下面的形式:

int a = 20;
int & const r = a;

因为 r 本来就不能改变指向,加上 const 是多此一举。

3) 指针可以有多级,但是引用只能有一级,例如,​​int **p​​​是合法的,而​​int &&r​​​是不合法的。如果希望定义一个引用变量来指代另外一个引用变量,那么也只需要加一个​​&​​,如下所示:

int a = 10;
int &r = a;
int &rr = r;

4) 指针和引用的自增(++)自减(--)运算意义不一样。对指针使用 ++ 表示指向下一份数据,对引用使用 ++ 表示它所指代的数据本身加 1;自减(--)也是类似的道理。请看下面的例子:

#include <iostream>
using namespace std;

int main (){
int a = 10;
int &r = a;
r++;
cout<<r<<endl;

int arr[2] = { 27, 84 };
int *p = arr;
p++;
cout<<*p<<endl;

return 0;
}

运行结果:
11
84

总结:引用本身是一个固定指向地址里面的内容,方便直接调用。

举报

相关推荐

0 条评论