【C++】类和对象（上）

最新推荐文章于 2024-07-25 09:44:13 发布

如意.759

最新推荐文章于 2024-07-25 09:44:13 发布

阅读量987

点赞数 36

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2402_82668782/article/details/140518658

版权

一、类的定义

1.1类的定义及使用

类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

• class为定义类的关键字，classname为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员；类中的变量称为类的属性或成员变量;类中的函数称为类的⽅法或者成员函数。

• C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，明显的变化是 struct中可以定义函数（C++中struct也可以定义函数），⼀般情况下我们还是推荐⽤class定义类。

// C++兼容C中struct的⽤法

typedef struct ListNodeC
{
 struct ListNodeC* next;
 int val;
}LTNode;
// 不再需要typedef，ListNodeCPP就可以代表类型

struct ListNodeCPP
{
 void Init(int x)
 {
 next = nullptr;
 val = x;
 }
 ListNodeCPP* next;
 int val;
};

• 定义在类⾯的成员函数默认为inline。

如有需要可以定义声明分离使其成为普通函数，但是内联函数是编辑器所决定的优化成为普通函数意义性不大。

1.2访问限定符

• C++⼀种实现封装的方式，⽤类将对象的属性与方法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的（暂且理解为私有的），以后继承章节才能体现出他们的区别。

• 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为止，如果后面没有访问限定符，作用域就到 } 即类结束。

• class定义成员没有被访问限定符修饰时默认为private，但是struct默认为public。

• ⼀般成员变量都会被限制为private/protected，需要给别⼈使用的成员函数会放为public。

1.3类域

• 类定义了⼀个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 ‘ :: ’ 作用域操作符指明成员属于哪个类域。

• 类域影响的是编译的查找规则，当不指明成员所属的域时默认会在全局作用域和当前作用域查找，没有找到就会报错（与namespace类似）。

二、类的实例化——对象

2.1实例化的概念

使用类类型在物理内存中创建对象的过程，称为类实例化出对象。

• 类是对象进行的⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量仅仅是声明，并没有分配空间，用类实例化出对象时，才会分配空间。

• ⼀个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，设计图规划了有多少个房间，房间⼤小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。

#include<iostream>
using namespace std;
class Date
{
public:
     void Init(int year, int month, int day)
     {
        _year = year;
        _month = month;
        _day = day;
     }
     void Print()
     {
        cout << _year << "/" << _month << "/" << _day << endl;
     }
private:
 // 这⾥只是声明，没有开空间
 int _year;
 int _month;
 int _day;
};

int main()
{
 // Date类实例化出对象d1和d2
 Date d1;
 Date d2;

 return 0;
}

2.2对象的大小

和c语言的结构体一样，类创建的实例对象中包含了各种成员，不同的是类还包含了成员函数。类实例化出的每个对象，都有独立的数据空间，所以对象中肯定包含成员变量，那么成员函数是否包含呢？

函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中非要存储的话，只能是成员函数的指针。但是指针确实一样的存储在对象中就浪费空间。如果用Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。这里需要再额外哆嗦一下，其实函数指针是不需要存储的，函数指针是⼀个地址，调用函数被编译成汇编指令[call 地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在运行时找，就需要存储函数地址。

简单说成员函数是类定义的必定是一样的，将成员函数放在一个公共的代码区域，这样就只需要存储一份。

类的成员变量则就和结构体中的一样，通过内存对齐的方式存储在对象中，而C++中的内存对齐规则和C是一模一样的。

2.3内存对齐的规则

1. 第⼀个成员在与结构体偏移量为0的地址处。

2.其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。

3.注意：对⻬数 = 编译器默认的⼀个对⻬数与该成员⼤⼩的较⼩值。

4.VS中默认的对⻬数为8。

5.结构体总⼤⼩为：最⼤对⻬数（中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的整数倍。

6.如果嵌套了结构体的情况，嵌套的结构体对⻬到自己成员变量的最⼤对⻬数的整数倍处，结构体的整体⼤⼩
就是所有最⼤对⻬数（含嵌套结构体的对⻬数）的整数倍。

例题 1

#include<iostream>
using namespace std;
class A
{
	char c1;
	int  i;
	char c2;

int main()
{
	A a;
	cout << sizeof(a) << endl;
}

答案：12

例题 2

#include<iostream>
using namespace std;
class A_
{
	char c1;
	char c2;
	int i;
};

int main()
{
	
	A_ a_;
	cout << sizeof(a_) << endl;
}

答案： 8

例题 3

#include<iostream>
using namespace std;
class A
{
	char c1;
	int  i;
	char c2;
};
class B
{
	int _b;
	class A a;
	char _a;
};
int main()
{
	A a;
	B b;

	cout << sizeof(b) << endl;
}

答案：20

类A的成员最大对齐数是int 4故应该是4的整数倍对齐开始存储对象a

为什么存在内存对齐呢？

1. 平台原因 (移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用⼀个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。

总体来说：结构体的内存对⻬是拿空间来换取时间的做法。

Tip：

#include<iostream>
using namespace std;
// 计算⼀下A/B实例化的对象是多⼤？

class A
{
 public:
        void Print()
         {
         //...
         }
};
class B
{};
int main()
{
 A a;
 B b;

 cout << sizeof(a) << endl;
 cout << sizeof(b) << endl;
//计算结果都是1字节！！
 return 0;
}

上述代码表明当类为空或者类只有成员函数时候，此时用类实例化的对象，对象的大小为1字节，用于表示对象的存在。

三、隐式的this指针

我们知道类实例化对象欧股，对类的成员变量和成员函数是分开存储的，只有变量存储在对象中，但是成员函数存储在其他地方而且函数体中并没有关于不同对象的区分，那么问题来了，函数是如何知道访问的是对象1还是对象2呢？？

这就需要介绍隐式的this指针了。

实例代码（注释为真实的成员函数模型）：

#include<iostream>
using namespace std;
class Date
{
public:
 // void Init(Date* const this, int year, int month, int day)
 void Init(int year, int month, int day)
 {
 _year = year;
//this->_year=year;
 this->_month = month;
 this->_day = day;
 }

 void Print()
 {
 cout << _year << "/" << _month << "/" << _day << endl;
 }
private:
 // 这⾥只是声明，没有开空间

 int _year;
 int _month;
 int _day;
};
int main()
{
 // Date类实例化出对象d1和d2,开辟空间
 Date d1;
 Date d2;
 // d1.Init(&d1, 2024, 3, 31);
 d1.Init(2024, 3, 31);
 d1.Print();
 d2.Init(2024, 7, 5);
 d2.Print();
 return 0;
}

• 编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this 指针。比如上述Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)以及void Print(Date*const this)

• 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this- >_year = year;

• C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显⽰使用this指针。

如意.759

关注

36
点赞
踩
20

收藏

觉得还不错? 一键收藏
5
评论
【C++】类和对象（上）

类是 C++ 的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。• class为定义类的关键字，classname为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员；类中的变量称为类的属性或成员变量;类中的函数称为类的⽅法或者成员函数。
复制链接

扫一扫