剖析【C++】——类与对象(上)超详解——小白篇

小李很执着

发布于 2024-06-15 10:05:38

29100

代码可运行

文章被收录于专栏：学习笔记学习笔记

运行总次数：0

代码可运行

1.面向过程和面向对象的初步认识

1.面向过程（Procedural Programming）

面向过程是一种编程范式，它主要关注程序的执行过程和步骤。程序员通过将问题分解为一个个具体的步骤和函数，逐步解决问题。面向过程的编程语言强调函数的调用和顺序的执行。

特点：

函数为中心：程序的逻辑是通过调用函数来实现的，每个函数执行特定的任务。
步骤明确：分析问题并明确解决步骤，通过函数逐步实现这些步骤。
数据和操作分离：数据和操作通常是分离的，通过函数来操作数据。

示例语言：

C语言
Pascal

示例代码（C语言）：

#include <stdio.h>

// 函数定义
void greet() {
    printf("Hello, World!\n");
}

int main() {
    // 调用函数
    greet();
    return 0;
}

在这个例子中，我们定义了一个叫做 greet 的函数，这个函数打印问候语。main 函数调用 greet 函数来实现问候。

2.面向对象（Object-Oriented Programming）

概念：

面向对象是一种编程方法，关注的是对象和对象之间的交互。我们把问题拆分成一个个对象，然后通过这些对象之间的合作来解决问题。
比如管理一家餐厅，我们有服务员对象、厨师对象、顾客对象，每个对象有自己的职责，他们之间的互动完成了餐厅的运作。

特点：

对象：把现实中的事物抽象成程序中的对象，每个对象都有属性和方法。
交互：对象之间通过方法相互协作完成任务。

示例语言：

简单示例（C++）：

#include <iostream>
using namespace std;

// 定义一个叫做 Person 的类
class Person {
public:
    // 类的属性
    string name;

    // 类的方法
    void greet() {
        cout << "Hello, " << name << "!" << endl;
    }
};

int main() {
    // 创建一个 Person 对象
    Person person;
    person.name = "World";

    // 调用对象的方法
    person.greet();

    return 0;
}

在这个例子中，我们定义了一个 Person 类，这个类有一个 name 属性和一个 greet 方法。我们创建了一个 Person 对象，设置了它的 name 属性，然后调用它的 greet 方法来打印问候语。

总结

面向过程：关注解决问题的步骤，通过函数调用一步步完成任务。
面向对象：关注对象和对象之间的交互，通过对象的方法来完成任务。

2.C++ 类的引入

1.从 C 语言的结构体到 C++ 的类

在 C 语言中，我们使用结构体（struct）来定义一组相关的变量。例如，一个表示点的结构体可以包含 x 和 y 坐标：

// C 语言的结构体
struct Point {
    int x;
    int y;
};

在这个例子中，Point 结构体只能包含变量 x 和 y，不能包含函数。

2.C++ 中的结构体和类

在 C++ 中，结构体不仅可以包含变量，还可以包含函数。这使得结构体比 C 语言中的结构体更加强大和灵活。例如，我们可以在结构体中定义一个函数来打印点的坐标：

// C++ 中的结构体
struct Point {
    int x;
    int y;

    // 结构体中的函数
    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

不过，在 C++ 中，更常用的是类（class），因为类提供了更多的功能和控制。类和结构体在语法上很相似，但有一些重要的区别：

默认访问权限：在结构体中，成员默认是公有的（public），而在类中，成员默认是私有的（private）。
类可以使用继承、封装、多态等高级特性。

3.使用类来替代结构体

我们可以使用类来定义一个更加完整的点类，包括私有变量和公有函数：

#include <iostream>
using namespace std;

// 定义一个 Point 类
class Point {
private:
    int x;
    int y;

public:
    // 构造函数
    Point(int xVal, int yVal) {
        x = xVal;
        y = yVal;
    }

    // 公有函数
    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    // 创建一个 Point 对象
    Point point(3, 4);

    // 调用对象的方法
    point.print();

    return 0;
}

在这个例子中，我们定义了一个 Point 类，它有私有的 x 和 y 变量，以及一个构造函数来初始化这些变量。我们还定义了一个 print 函数来打印点的坐标。这样，类不仅封装了数据，还提供了操作数据的方法。

4.总结

C 语言结构体：只能定义变量，不能包含函数。
C++ 结构体：不仅可以定义变量，还可以包含函数。
C++ 类：更常用，提供了更多功能和控制，如私有变量、公有函数、构造函数等。

通过引入类，C++ 提供了更强大的工具来组织和管理代码，使得代码更易于维护和扩展。

3.类的定义

1.什么是类？

类是一个模板，它定义了一种新的数据类型，这种类型包含数据（变量）和功能（函数）。可以把类想象成一种蓝图，用来创建对象（具体的实例）。

2.如何定义一个类？

用 class 关键字来定义一个类。类的名字可以是你选择的任何名字，类的主体包含变量和函数。在类定义的最后要加上一个分号 ;。

类的成员

成员变量：类里面的变量，称为属性。
成员函数：类里面的函数，称为方法。

示例 1：简单的类定义

我们来定义一个表示点（Point）的类，这个类有两个属性 x 和 y，以及一个打印点坐标的方法。

#include <iostream>
using namespace std;

class Point {
public:
    int x; // 成员变量
    int y; // 成员变量

    // 成员函数
    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point point; // 创建一个 Point 对象
    point.x = 3; // 设置属性 x
    point.y = 4; // 设置属性 y

    point.print(); // 调用成员函数

    return 0;
}

在这个例子中，Point 类定义了两个变量 x 和 y，还有一个打印点坐标的函数 print。在 main 函数中，我们创建了一个 Point 对象，设置了它的 x 和 y 值，然后调用 print 方法打印坐标。

3.两种类的定义方式

1.全部在类体中

简单直接，适合小项目或示例代码。
成员函数在类中定义，可能会被编译器当成内联函数（优化的一种）。

class Point {
public:
    int x;
    int y;

    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

2.分开声明和定义

更清晰，适合大型项目。
类的声明放在头文件（.h 文件）中，成员函数的定义放在源文件（.cpp 文件）中。

Point.h：

#ifndef POINT_H
#define POINT_H

class Point {
public:
    int x;
    int y;

    void print();
};

#endif // POINT_H

Point.cpp：

#include <iostream>
#include "Point.h"
using namespace std;

void Point::print() {
    cout << "Point(" << x << ", " << y << ")" << endl;
}

main.cpp：

#include "Point.h"

int main() {
    Point point;
    point.x = 3;
    point.y = 4;

    point.print();

    return 0;
}

4.总结

类：用 class 定义，包含变量和函数。
成员变量：类里面的变量，称为属性。
成员函数：类里面的函数，称为方法。
两种定义方式：全部放在类体中或分开声明和定义。

4.C++ 类的访问限定符及封装

1.访问限定符

C++ 提供了访问限定符来控制类成员（属性和方法）的访问权限。通过这些限定符，我们可以实现封装，让类更加安全和易于维护。

1.访问限定符有三种：

public：公有成员可以在类外部直接访问。
protected：保护成员不能在类外部直接访问，但可以在子类中访问。
private：私有成员不能在类外部直接访问，仅能在类的内部访问。

2.注意：

访问权限从访问限定符出现的位置开始，直到下一个访问限定符出现为止。如果没有下一个访问限定符，则作用域一直到类的结束。
在 class 中，默认访问权限是 private。在 struct 中，默认访问权限是 public。

示例：

#include <iostream>
using namespace std;

class Person {
public:
    string name; // 公有成员变量

protected:
    int age; // 保护成员变量

private:
    string secret; // 私有成员变量

public:
    // 构造函数
    Person(string n, int a, string s) : name(n), age(a), secret(s) {}

    // 公有成员函数
    void showInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }

    // 私有成员函数
    void showSecret() {
        cout << "Secret: " << secret << endl;
    }
};

int main() {
    Person person("Alice", 30, "Loves coding");

    // 直接访问公有成员
    cout << "Name: " << person.name << endl;

    // 直接调用公有成员函数
    person.showInfo();

    // 尝试访问保护和私有成员会导致编译错误
    // cout << "Age: " << person.age << endl; // 错误
    // cout << "Secret: " << person.secret << endl; // 错误

    return 0;
}

2.C++ 中 `struct` 和 `class` 的区别

在 C++ 中，struct 可以用来定义类，其功能与 class 基本相同，唯一的区别在于默认的访问权限不同：

struct 默认访问权限是 public。
class 默认访问权限是 private。

示例：

struct Point {
    int x;
    int y;

    void print() {
        cout << "Point(" << x << ", " << y << ")" << endl;
    }
};

class Circle {
private:
    int radius;

public:
    void setRadius(int r) {
        radius = r;
    }

    void showRadius() {
        cout << "Radius: " << radius << endl;
    }
};

3.封装

封装是面向对象编程的三大特性之一。它将数据和操作数据的方法有机结合，隐藏对象的属性和实现细节，仅对外公开接口来与对象进行交互。

1.封装的优势：

隐藏实现细节：用户不需要知道内部如何实现，只需通过公开的接口与对象交互。
提高代码安全性：通过控制访问权限，防止外部直接修改对象内部状态。
增强代码维护性：内部实现可以随时更改而不影响外部代码。

现实例子： 就像使用计算机时，我们不需要知道内部的工作原理，只需要通过键盘、鼠标、显示器等接口与计算机交互即可。

在 C++ 中实现封装： 通过类将数据和方法结合在一起，并使用访问限定符来控制访问权限。

示例：

class Computer {
private:
    string cpu;
    int memory;

public:
    // 构造函数
    Computer(string c, int m) : cpu(c), memory(m) {}

    // 公有成员函数
    void start() {
        cout << "Computer started with CPU: " << cpu << " and Memory: " << memory << "GB" << endl;
    }
};

int main() {
    Computer myComputer("Intel i7", 16);
    myComputer.start(); // 通过公开的接口与对象交互

    // 直接访问私有成员会导致编译错误
    // cout << myComputer.cpu << endl; // 错误

    return 0;
}

5.总结

访问限定符：控制类成员的访问权限，分为 public、protected 和 private。
封装：将数据和方法结合，隐藏实现细节，只公开必要的接口，提高代码安全性和可维护性。
struct 和 class 的区别：struct 默认访问权限是 public，class 默认访问权限是 private。

5.类的作用域

在 C++ 中，类定义了一个新的作用域。类的所有成员（变量和函数）都在这个类的作用域中。如果在类体外定义成员函数，需要使用 :: 作用域操作符来指明成员属于哪个类。

1.作用域和作用域操作符

什么是作用域？ 作用域指的是变量或函数在程序中可以被访问的区域。在类中，类的作用域指的是类的所有成员变量和成员函数的可访问范围。 作用域操作符 :: 作用域操作符 :: 用于指定一个变量或函数属于哪个作用域。在类体外定义成员函数时，需要使用 :: 来指明函数属于哪个类。

示例：

2.在类体外定义成员函数

假设我们有一个表示点（Point）的类，包含两个成员变量 x 和 y 以及一个打印点坐标的成员函数 print。

我们可以在类体内声明成员函数，然后在类体外定义它们。

Step 1: 类声明

在头文件（如 Point.h）中声明类和成员函数：

#ifndef POINT_H
#define POINT_H

class Point {
public:
    int x;
    int y;

    // 声明成员函数
    void print();
};

#endif // POINT_H

Step 2: 类体外定义成员函数

在源文件（如 Point.cpp）中定义成员函数：

#include <iostream>
#include "Point.h"
using namespace std;

// 使用作用域操作符 :: 来定义成员函数
void Point::print() {
    cout << "Point(" << x << ", " << y << ")" << endl;
}

Step 3: 使用类

在主文件（如 main.cpp）中使用这个类：

#include "Point.h"

int main() {
    Point point;
    point.x = 3;
    point.y = 4;

    point.print(); // 调用成员函数

    return 0;
}

3.总结

类定义了一个新的作用域：类的所有成员都在类的作用域中。
在类体外定义成员函数：需要使用作用域操作符 :: 指明成员属于哪个类。
示例代码：通过分离声明和定义的方式，使用 :: 作用域操作符在类体外定义成员函数

6.类的实例化

类的实例化是用类类型创建对象的过程。可以把类看作一种描述或模板，通过这个模板可以创建具体的对象。

1. 类是一个描述

类就像一个模型或模板，它定义了对象的成员（变量和函数），但本身并不占用内存空间。例如，一个 Person 类可能包含成员变量 name 和 age，以及成员函数 printInfo，但只有在实例化出具体对象时，这些成员才会实际占用内存空间。

类的例子：

class Person {
public:
    string name;
    int age;

    void printInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

现实类比： 类就像一张空的学生信息表，它描述了学生有哪些信息（比如姓名和年龄），但没有具体存储任何学生的信息。只有在填写表格时，才会有具体的学生数据。

2. 类的实例化

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

实例化对象的例子：

int main() {
    // 创建 Person 类的对象（实例化）
    Person person1;
    person1.name = "Alice";
    person1.age = 30;

    Person person2;
    person2.name = "Bob";
    person2.age = 25;

    // 调用对象的成员函数
    person1.printInfo();
    person2.printInfo();

    return 0;
}

在这个例子中，我们实例化了两个 Person 对象，分别是 person1 和 person2。这些对象各自拥有自己的 name 和 age，并实际占用了内存空间。

3. 类与对象的类比

类实例化出对象就像使用建筑设计图建造房子：

类：就像建筑设计图，定义了房子应该有什么样子（例如有几间房、什么颜色的墙壁），但设计图本身并不是房子。
对象：就像根据设计图建造出来的房子，房子是实际存在的，占用了物理空间。

类与对象的关系：

类：模板或蓝图，描述了对象的特性和行为。
对象：类的实例，实际存在并占用内存空间，存储类的成员变量。

4.总结

类是一个描述：类定义了对象的成员，但本身不占用内存空间。
实例化对象：通过类创建对象，对象占用实际的物理空间，存储类的成员变量。
类与对象的类比：类就像设计图，实例化出的对象就像建造出来的房子。

7.类对象模型

在 C++ 中，类的对象模型描述了类的实例（对象）在内存中的存储方式。了解这个模型对于优化程序性能和理解内存管理非常重要。

7.1 如何计算类对象的大小

问题： 一个类的对象包含什么？如何计算一个类的大小？

回答： 一个类的对象包含类的成员变量，但不直接包含成员函数。成员函数在公共的代码段中存储。类的对象大小实际上是该类中所有成员变量的大小之和，考虑内存对齐后得到的结果。

示例：

class MyClass {
public:
    int a;
    double b;

    void myFunction() {}
};

int main() {
    MyClass obj;
    cout << "Size of MyClass: " << sizeof(MyClass) << endl; // 输出类对象的大小
    return 0;
}

7.2 类对象的存储方式

对象模型猜测：

成员变量存储在对象中：每个对象都包含自己的成员变量。
成员函数存储在公共代码段：成员函数只存储一份，在对象中保存指向函数代码的地址。

这样可以节省内存空间，因为多个对象共享同一份成员函数代码。

存储方式总结：

成员变量：存储在每个对象中，占用实际内存空间。
成员函数：存储在公共代码段，所有对象共享，节省内存空间。

示例：

class MyClass {
public:
    int a;
    double b;

    void myFunction() {
        cout << "Hello" << endl;
    }
};

int main() {
    MyClass obj1;
    MyClass obj2;

    // 输出类对象的大小
    cout << "Size of MyClass: " << sizeof(MyClass) << endl;
    return 0;
}

7.3 结构体内存对齐规则

内存对齐是为了提高内存访问效率，使得 CPU 可以快速读取和写入数据。

内存对齐规则：

第一个成员在与结构体偏移量为 0 的地址处：即第一个成员从 0 地址开始。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处：对齐数是编译器默认对齐数和成员大小的较小值。
结构体总大小为最大对齐数的整数倍：即所有成员变量类型最大值和默认对齐参数的最小值的整数倍。
嵌套结构体：嵌套的结构体对齐到自己的最大对齐数的整数倍处，整体大小为所有最大对齐数的整数倍。

示例：

#include <iostream>
using namespace std;

struct MyStruct {
    char a;
    int b;
    double c;
};

int main() {
    cout << "Size of MyStruct: " << sizeof(MyStruct) << endl; // 输出结构体大小
    return 0;
}

内存对齐示例：

char 对齐到 1 字节
int 对齐到 4 字节
double 对齐到 8 字节

计算大小：

a 从偏移量 0 开始，占 1 字节。
b 需要对齐到 4 字节，从偏移量 4 开始，占 4 字节。
c 需要对齐到 8 字节，从偏移量 8 开始，占 8 字节。
结构体总大小是 8 的整数倍，即 16 字节。

7.4面试题

结构体怎么对齐？为什么要进行内存对齐？

回答： 结构体的每个成员按照对齐规则对齐，具体规则如上所述。内存对齐是为了提高内存访问效率，使 CPU 可以快速读取和写入数据。

如何让结构体按照指定的对齐参数进行对齐？能否按照 3、4、5 即任意字节对齐？

回答： 可以使用编译器提供的指令来指定对齐参数，例如 #pragma pack 指令。可以按照任意字节对齐，但通常使用的是 1、2、4、8 等字节对齐。

#pragma pack(push, 1)
struct MyStruct {
    char a;
    int b;
    double c;
};
#pragma pack(pop)

什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景？

回答： 大端（Big-endian）和小端（Little-endian）是两种字节序，决定了多字节数据的存储顺序。大端将最高字节存储在最低地址，小端将最低字节存储在最低地址。

测试方法：

#include <iostream>
using namespace std;

int main() {
    unsigned int x = 1;
    char *c = (char*)&x;
    if (*c)    
        cout << "Little-endian" << endl;
    else
        cout << "Big-endian" << endl;
    return 0;
}

场景： 网络传输、文件存储时需要考虑大小端问题，因为不同系统可能使用不同的字节序，需要进行转换以确保数据正确解析。

8.C++ 类成员函数的 this 指针

8.1 this 指针的引出

当我们定义一个类，并在类中包含成员函数时，这些函数需要知道它们是属于哪个对象。例如，我们定义一个日期类 Date：

class Date {
public:
    int day;
    int month;
    int year;

    void Init(int d, int m, int y) {
        day = d;
        month = m;
        year = y;
    }

    void Print() {
        cout << day << "/" << month << "/" << year << endl;
    }
};

问题： 当我们有两个对象 d1 和 d2 时，调用 d1.Init(1, 1, 2020) 和 d2.Init(2, 2, 2021)，函数是如何区分这两个对象的？

解决方法： C++ 编译器通过引入 this 指针来解决这个问题。this 指针是一个隐藏的指针参数，指向当前对象（即调用成员函数的对象）。在成员函数内部，所有的成员变量访问都是通过 this 指针实现的。

8.2 this 指针的特性

this 指针的类型：类类型* const，即 this 指针是指向类对象的常量指针，不能修改 this 指针的指向。
只能在成员函数内部使用：this 指针只能在成员函数中使用。
this 指针是成员函数的形参：当对象调用成员函数时，对象的地址作为实参传递给 this 指针。所以对象本身并不存储 this 指针。
this 指针由编译器维护：this 指针是成员函数的第一个隐含的指针形参，编译器会自动处理，不需要用户传递。

示例：

class Date {
public:
    int day;
    int month;
    int year;

    void Init(int d, int m, int y) {
        this->day = d;
        this->month = m;
        this->year = y;
    }

    void Print() {
        cout << this->day << "/" << this->month << "/" << this->year << endl;
    }
};

8.3面试题

this 指针存在哪里？ 回答： this 指针存储在成员函数的形参列表中，由编译器在调用成员函数时自动传递，通常通过寄存器（如 ecx 寄存器）传递。
this 指针可以为空吗？ 回答： 在正常情况下，this 指针不会为空，因为它指向的是当前调用成员函数的对象。但是在某些特定情况下（如对象被错误地删除或未正确初始化），this 指针可能会变成空指针或指向无效地址。

8.4 C 语言和 C++ 实现 Stack 的对比

1. C 语言实现 Stack

在 C 语言中，实现 Stack 通常需要定义一个结构体，并且所有操作都通过函数来实现。

示例：

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int top;
    int capacity;
} Stack;

// 初始化栈
void InitStack(Stack *s, int capacity) {
    s->data = (int *)malloc(capacity * sizeof(int));
    s->top = -1;
    s->capacity = capacity;
}

// 压栈
void Push(Stack *s, int value) {
    if (s->top < s->capacity - 1) {
        s->data[++s->top] = value;
    }
}

// 出栈
int Pop(Stack *s) {
    if (s->top >= 0) {
        return s->data[s->top--];
    }
    return -1; // 栈空
}

// 打印栈
void PrintStack(Stack *s) {
    for (int i = 0; i <= s->top; i++) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}

在 C 语言中，每个函数都需要传递 Stack 指针作为参数，并且需要手动检查指针是否为 NULL。

2. C++ 实现 Stack

在 C++ 中，通过类可以将数据和操作数据的方法结合在一起。这样使用时更方便，且更加符合人类对事物的认知。

示例：

#include <iostream>
using namespace std;

class Stack {
private:
    int *data;
    int top;
    int capacity;

public:
    // 构造函数
    Stack(int capacity) {
        this->data = new int[capacity];
        this->top = -1;
        this->capacity = capacity;
    }

    // 析构函数
    ~Stack() {
        delete[] data;
    }

    // 压栈
    void Push(int value) {
        if (top < capacity - 1) {
            data[++top] = value;
        }
    }

    // 出栈
    int Pop() {
        if (top >= 0) {
            return data[top--];
        }
        return -1; // 栈空
    }

    // 打印栈
    void PrintStack() {
        for (int i = 0; i <= top; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    Stack s(10);
    s.Push(1);
    s.Push(2);
    s.Push(3);

    s.PrintStack();

    s.Pop();
    s.PrintStack();

    return 0;
}

在 C++ 中，Stack 类将数据和操作方法结合在一起，使用时不需要显式传递 Stack 指针，因为编译器会自动处理 this 指针。

8.5总结

this 指针的引出：解决成员函数区分不同对象的问题，this 指针指向当前对象。
this 指针的特性：只能在成员函数内部使用，编译器自动传递。
C 语言和 C++ 实现 Stack 的对比：C 语言通过函数操作结构体，C++ 通过类将数据和方法结合，更加方便和安全。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-05-27，如有侵权请联系 cloudcommunity@tencent.com 删除

对象

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！