C++从入门到精通——类的作用域及类的实例化

---

前言

类的作用域是指类中定义的变量和方法的可见性和可访问性范围。在类的内部，所有成员（包括属性和方法）都具有类作用域，意味着它们可以在类的任何方法中被访问。然而，类的外部无法直接访问这些成员，除非通过类的实例或类本身（对于静态成员）。类的成员可以被设置为公有（public）、私有（private）或受保护的（protected），以控制其在不同上下文中的可见性和可访问性。这种作用域的控制有助于封装和隐藏类的实现细节，同时提供清晰的接口供外部使用。

类的实例化是指创建一个类的具体对象的过程。这通常涉及分配内存空间给新创建的对象，并设置其初始属性值。在实例化过程中，会调用类的构造函数来初始化对象的状态。一旦对象被实例化，就可以通过该对象来访问类的属性和方法，从而实现对对象的操作。类的实例化是面向对象编程中非常重要的概念，它使得程序员能够创建多个具有相同属性和方法的对象，并通过这些对象来模拟现实世界中的实体和它们之间的关系。

---

一、类的作用域

类的作用域是指类中定义的成员变量（属性）和方法可被访问的范围。

• 类的作用域可以分为三个级别，分别为：

  • 公有作用域（public）：公有作用域的成员变量和方法可以在类的外部被访问和调用。公有作用域的成员可以被其他类继承和重写。
  • 私有作用域（private）：私有作用域的成员变量和方法只能在类的内部被访问和调用，无法被外部类或子类直接访问。私有作用域的成员只能被本类中的其他方法使用。
  • 受保护作用域（protected）：受保护作用域的成员变量和方法可以在类的内部和子类中被访问和调用。受保护作用域的成员不能被外部类直接访问。

• 类定义了一个新的作用域（即上述提到的三个作用域）
  类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

using namespace std;
class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过合理地使用作用域，可以控制类中成员的访问权限，提高代码的封装性和安全性。同时，类的作用域也可以使代码更加模块化，便于理解和维护。

二、类的实例化

用类的类型创建对象的过程，称为类的实例化

引例

#include<iostream>
using namespace std;
class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}
int main()
{
	Person man;
	cout << sizeof(man) << endl;
	cout << sizeof(Person) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<iostream>
using namespace std;
class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}
int main()
{
	Person man;
	cout << sizeof(Person) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include<iostream>
using namespace std;
class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}
int main()
{
	cout << sizeof(Person) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

通过这个我们可以发现许多问题

• 为什么只算成员变量的空间而不算成员函数的空间

ps：类的存储空间的计算和结构体空间计算是一样的，不会计算结构体内存空间的可以看这篇文章——C语言从入门到实战——结构体与位段，也可以看我的下一篇文章

成员变量和成员函数在C++中是不同的概念，它们具有不同的存储方式和使用方式。

成员变量是对象的属性，用于存储对象的状态信息。它们在对象被创建时分配空间，并随着对象的销毁而释放空间。因此，我们在计算一个对象所占空间大小时，会考虑其中的成员变量。

成员函数是用来操作对象的行为，它们并不存储在对象内部，而是作为对象的一部分存在于对象所属的类中。成员函数的代码只有一份，被所有属于同一个类的对象共享。因此，计算对象所占空间时，并不考虑其中的成员函数。

此外，成员函数也不占用对象的存储空间，它们只是通过对象来进行调用。因此，成员函数并不会对对象的大小产生直接影响。

• 为什么直接计算没有实例化的类的空间大小是存在的
  在计算机内存中，每个类的定义都占据一定的内存空间，即使没有实例化该类的对象。这是因为类定义中包含了类的成员变量、成员函数以及其他元数据信息，这些信息需要在内存中存储以供程序在运行时使用。
  类的成员变量在内存中按照定义顺序进行存储，每个成员变量占据一定的内存空间。成员函数的代码也需要在内存中存储，以便可以被调用执行。其他元数据信息如类名、类的继承关系、访问控制等也需要在内存中存储。
  即使没有实例化类的对象，也可以通过类名来访问静态成员变量和函数。这些静态成员变量和函数在内存中是独立存在的，因此需要占据一定的内存空间。
  所以，尽管没有实例化类的对象，但类的定义本身仍然需要占据一定的内存空间。这样可以确保程序在运行时可以正确访问和使用类的成员变量和函数。

类是对对象进行描述的

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。

谜语：“年纪不大，胡子一把，主人来了，就喊妈妈”

谜底：山羊

示例

可以在C++中定义一个类，但是不分配实际的内存空间来存储它。例如：

class MyClass {
  public:
    int myInt;
    void myMethod() {
      // do something
    }
};

int main() {
    // 在这里定义一个MyClass对象，但没有分配内存空间存储它
    // 只是声明对象的存在，但不会分配内存空间
    MyClass myObject;

    // 通过访问成员变量和调用成员方法，可以使用对象的属性和行为
    myObject.myInt = 10;
    myObject.myMethod();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个例子中，我们定义了一个名为MyClass的类，并声明了一个MyClass类型的变量myObject，但并没有实际分配内存空间来存储它。在main()函数中，通过访问myObject的成员变量myInt和调用成员方法myMethod()，可以使用对象的属性和行为。然而，由于没有分配内存空间，这些操作只是模拟了对象的行为，实际上并没有真正的对象存在。

一个类可以实例化出多个对象

一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

int main()
{
	Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”
	return 0;
}
1
2
3
4
5

Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

示例

如下的例子是一个汽车类，每个汽车对象都可以有不同的颜色、品牌和型号。你可以创建多个汽车对象，每个对象都代表不同的车辆。

#include <iostream>
#include <string>

class Car {
public:
    std::string brand;
    std::string model;
    std::string color;
};

int main() {
    Car car1;
    car1.brand = "Toyota";
    car1.model = "Camry";
    car1.color = "Blue";

    Car car2;
    car2.brand = "Honda";
    car2.model = "Civic";
    car2.color = "Red";

    // 输出 car1 的属性
    std::cout << "Car 1:" << std::endl;
    std::cout << "Brand: " << car1.brand << std::endl;
    std::cout << "Model: " << car1.model << std::endl;
    std::cout << "Color: " << car1.color << std::endl;

    // 输出 car2 的属性
    std::cout << "Car 2:" << std::endl;
    std::cout << "Brand: " << car2.brand << std::endl;
    std::cout << "Model: " << car2.model << std::endl;
    std::cout << "Color: " << car2.color << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

这个例子中，我们定义了一个Car类，具有品牌（brand）、型号（model）和颜色（color）属性。我们创建了两个不同的Car对象car1和car2，并为它们的属性赋值。然后，我们通过输出语句打印出每个汽车对象的属性。这样，我们可以实例化出多个不同的汽车对象。

示例

类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

---