C++面向对象整理（1）之初识类和对象

C++面向对象整理（1）之初识类和对象

注：整理一些突然学到的C++知识，随时mark一下
例如：忘记的关键字用法，新关键字，新数据结构

---

---

提示：本文为 C++ 中 类定义、成员函数 的写法和举例

---

一、类的定义

  类（class）就是自定义一种数据结构，这个数据结构就是更高级版本的C的结构体struct，拥有很多属性数据，但更一步相比结构体，类还新增了很多函数（称为成员函数、或方法），这些函数可以把这些属性数据当成传递的参数施加运算（如初始化赋值）或操作，而且还可以传新的参数，同时这些函数可以通过访问权限控制是否可以传入/访问这些数据。
在C++中，定义类（class）的基本语法如下：

class ClassName {  
     访问权限:
              类内给出类的成员变量的声明  
     访问权限:
     		  类内给出类的成员函数的声明或实现  
};

//类外定义成员函数，使用冒号
返回类型 ClassName::成员函数的实现

注意工程上一般将类分文件编写定义，h文件中写类的声明，源文件中写类的函数的具体实现。当然也可以一次性写在一个文件里。

类的成员函数可以分为以下几种类型：

（1）普通成员函数：这是最常见的成员函数类型，它们执行类的特定操作，并且通常依赖于类的特定实例（对象）来执行。

（2）构造函数：构造函数是一种特殊的成员函数，它在创建类的对象时被自动调用，用于初始化对象的成员变量。构造函数的名字必须与类名相同，并且不能有返回类型。构造函数可以重载，可以有多个构造函数，以应对不同的初始化需求（这个非常重要，这里后面讲）。

（3）析构函数：析构函数也是特殊的成员函数，它在对象的生命周期结束时被调用，用于执行清理工作、释放分配的内存等。析构函数的名字是类名前加上波浪号 ~。

（3）赋值操作符重载函数：这是重载的赋值操作符就是等于号 = ，用于实现对象之间的赋值操作。（后面讲）

（4）取地址操作符重载函数和const修饰的取地址操作符重载函数：这些是重载的取地址操作符（&），分别用于获取对象的地址和const对象的地址。

（5）virtual的成员函数：其地址指向vtable（虚函数表）中的位置，通常用于实现多态。

（6）static的成员函数：不依赖于类的对象而存在的函数，也不依赖于类的对象而调用。关于static和const
（7）const的成员函数：表示该函数不能擅自改变成员变量的值。

1、类成员的访问权限

类的访问权限有三种：

public：公开的，表示这个成员可以在任何地方被访问。
protected：受保护的，表示这个成员可以在该类及其派生类中被其访问，但不能被该类的对象通过点运算符访问。
private：私有的，表示这个成员只能在类的内部被访问，类的外部无法直接访问。如果没有明确指定访问权限，那么默认是private。

2、类定义示例

现在，我们来定义一个坐标点类Point，包含空间三维坐标（x, y, z）并提供提取GET或设置SET坐标值和一个求距离的接口distanceTo（方法），假设定义的距离是两点之间的欧几里得距离。

（1）类内定义

#include <cmath> // 用于sqrt函数 

class Point {  
public:  
	Point(double x, double y, double z) {  
    // 这里构造函数直接赋值  
    x_ = x;  
    y_ = y;  
    z_ = z;  
}  
   
    // 获取x坐标  
    double getX() const { return x_; }  
  
    // 获取y坐标  
    double getY() const { return y_; }  
  
    // 获取z坐标  
    double getZ() const { return z_; }  
  
    // 设置x坐标  
    void setX(double x) { x_ = x; }  
  
    // 设置y坐标  
    void setY(double y) { y_ = y; }  
  
    // 设置z坐标  
    void setZ(double z) { z_ = z; }  
  
    // 计算两点之间的欧几里得距离  
    double distanceTo(const Point& other) const {  
        double dx = x_ - other.x_;  
        double dy = y_ - other.y_;  
        double dz = z_ - other.z_;  
        return std::sqrt(dx * dx + dy * dy + dz * dz);  
    }  
  
private:  
    // 坐标变量  
    double x_;  
    double y_;  
    double z_;  
};

构造函数也可以写成以下初始化列表形式，也可用于用于初始化

Point(double x = 0.0, double y = 0.0, double z = 0.0)   
    : x_(x), y_(y), z_(z) {}  

（2）类外定义成员函数

比如我们要将Point类分为头文件（.h）和源文件（.cpp）分开编写，类外定义不一定要分开写，只是工程上一般这样写。

首先是头文件Point.h：

// Point.h  
#ifndef POINT_H  
#define POINT_H  
  
#include <cmath> // 包含cmath库以使用std::sqrt  
  
class Point {  
public:  
    // 构造函数，用于初始化坐标  
    Point(double x = 0.0, double y = 0.0, double z = 0.0);  
  
    // 获取x坐标  
    double getX() const;  
  
    // 获取y坐标  
    double getY() const;  
  
    // 获取z坐标  
    double getZ() const;  
  
    // 设置x坐标  
    void setX(double x);  
  
    // 设置y坐标  
    void setY(double y);  
  
    // 设置z坐标  
    void setZ(double z);  
  
    // 计算两点之间的欧几里得距离  
    double distanceTo(const Point& other) const;  
  
private:  
    // 坐标变量  
    double x_;  
    double y_;  
    double z_;  
};  
  
#endif // POINT_H

然后是源文件Point.cpp：

// Point.cpp  
#include "Point.h"  
  
// 构造函数实现  
Point::Point(double x = 0, double y = 0, double z = 0) {  
    // 这里直接赋值  
    x_ = x;  
    y_ = y;  
    z_ = z;  
}  
  
// 获取x坐标  
double Point::getX() const {  
    return x_;  
}  
  
// 获取y坐标  
double Point::getY() const {  
    return y_;  
}  
  
// 获取z坐标  
double Point::getZ() const {  
    return z_;  
}  
  
// 设置x坐标  
void Point::setX(double x) {  
    x_ = x;  
}  
  
// 设置y坐标  
void Point::setY(double y) {  
    y_ = y;  
}  
  
// 设置z坐标  
void Point::setZ(double z) {  
    z_ = z;  
}  
  
// 计算两点之间的欧几里得距离  
double Point::distanceTo(const Point& other) const {  
    double dx = x_ - other.x_;  
    double dy = y_ - other.y_;  
    double dz = z_ - other.z_;  
    return std::sqrt(dx * dx + dy * dy + dz * dz);  
}

在这个Point类中，我们定义了：

一个构造函数，用于初始化坐标值。
getX(), getY(), getZ()方法，用于获取坐标值。
setX(), setY(), setZ()方法，用于设置坐标值。
distanceTo()方法，用于计算当前点到另一个点的欧几里得距离。
x_, y_, z_是私有成员变量，只能在Point类内部访问，而公开的getX(), getY(), getZ(), setX(), setY(), setZ()方法提供了对私有成员变量的访问接口。distanceTo()方法使用了私有成员变量来计算距离。这样定义的类既保证了成员变量的封装性（只有类内部才能直接访问），又提供了公共接口供外部使用。

3、类对象（实例）的定义及初始化

有了自己定义好的class类型，我们就可以用它声明和初始化属于这个类的对象变量（实例 instance），比如，对于内置的数据类型有 int a = 1; int a; int b = a; 那么类该如何对应的实现上述初始化方式呢：
基于上面的类class Point来说明
于是：
（1）对应int a;

Point p1; 

执行这段代码时会立即调用定义的构造函数创建一个Point对象，坐标默认为(0, 0, 0)。

（1）对应int a = 1;

因为类有很多数据成员，但又不可能像python写作Point A ={1，2，3} 这么简单（好吧其实后面C++也引入了花括号的写法），因为编译器压根不知这是啥，所以必须引入构造函数来给每个数据成员初始化赋值：

Point p2(1.0, 2.0, 3.0); // 使用带参数的构造函数创建一个Point对象，坐标为(1.0, 2.0, 3.0)

（2）对应int b = a;

Point p3(p2); // 使用拷贝构造函数创建一个Point对象，坐标也为(1.0, 2.0, 3.0)
或者
Point p3 = p2; //若有重载的等号赋值

关于拷贝构造和重载运算符这里先不讲，记住这个语法形式即可。

（3）对应 int *p = & a;

Point * pointerP = & p3

但一般使用new关键字或智能指针在堆上动态创建对象（关于这两个详见前面关于动态内存new、关于智能指针）

Point* pointerP = new Point(7.0, 8.0, 9.0); // 在堆上动态创建一个Point对象，并返回指向它的指针

4、类的匿名对象

匿名对象（也称为临时对象）是指没有显式名称的对象。对于类来说，这意味着创建了一个类的对象，但没有给它一个变量名来用它。匿名对象通常用于那些只需要执行一次操作，如执行一次某个成员函数，并且之后不再需要引用的情况。匿名对象会在执行完构造函数或者调用成员函数后立即被销毁。一个类A的匿名对象的格式是A()或A(paras)。

例如，上面的Point类，我只想执行一次计算距离函数来得到两个点的距离dist：

double dist = Point(-1,-2,-3).distanceTo(p2);//Point(-1,-2,-3)就是匿名对象

再比如有一个简单的类，它有一个输出消息的成员函数：

class MessagePrinter {
public:
    void printMessage(const std::string& msg) const {
        std::cout << msg << std::endl;
    }
};

可以创建一个匿名对象并立即调用其成员函数，如下所示：

MessagePrinter().printMessage("Hello, World!");

本例MessagePrinter() 创建了一个 MessagePrinter 类的匿名对象，并立即调用了其 printMessage 成员函数。由于这个对象没有名称，因此它只存在于这次函数调用期间。当 printMessage 函数执行完毕后，这个匿名对象就会被销毁。

5、类对象的内存分配

成员变量和成员函数在内存中的存储和访问方式有着根本的区别。在内存中，一个类的对象通常按照成员变量的声明顺序进行布局。成员变量的内存布局可能受到内存对齐规则的影响，以确保访问效率。而成员函数则不直接占用对象的内存空间，它们的代码在程序的代码段中，成员变量是每个对象特有的，而成员函数则是类共有的。

成员变量：
成员变量是类定义中的一部分，它们存储在类的对象中。当你创建一个类的对象时，系统会在内存中为对象的每个成员变量分配空间。这些空间通常位于堆（如果使用new操作符）或栈（如果在函数内部创建对象）上。每个对象都有自己的成员变量副本，因此修改一个对象的成员变量不会影响其他对象的成员变量，除非这些对象之间通过引用或指针相互关联。

成员函数：
成员函数也是类定义中的另一部分，但它们并不直接存储在类的对象中。相反，成员函数通常存储在代码段中，这是程序的可执行部分。每个成员函数只有一个代码实例，无论创建了多少个类的对象，只有一块内存成员函数。当对象调用成员函数时，函数代码被执行，并且函数的参数（如果有的话）以及类的this指针（指向调用该函数的对象的指针）被传递给函数。

this指针（后面讲）
在成员函数内部，可以通过this指针访问调用该函数的对象的成员变量。this指针是一个隐含的指针，它指向调用成员函数的对象。通过this指针，成员函数可以访问和修改对象的成员变量。

静态成员
静态成员变量和静态成员函数是类的特殊成员。静态成员变量不属于任何特定的对象实例，而是属于类本身。它们只存储一份，而不是每个对象一份。静态成员函数也是属于类本身的，它们不能访问非静态成员变量（除非通过对象或引用），但可以直接访问静态成员变量和其他静态成员函数。