类和对象（一）

类可以视为一种声明，声明某个东西所拥有的特点，功能。比如说鸟，是一种概念，声明了这种生物有翅膀，可以飞，眼睛长在头的两侧，嘴被称为喙，是尖的。而各种鸟是这个鸟的概念的实例化，拥有所声明的这些特点。

在代码中的体现是，类声明了拥有什么参数，参数的类型，拥有什么函数，而实例化的对象拥有声明的所有参数函数等等。类的名字不能重复，但是一个类的实例化对象可以有多个，彼此相互独立。
 

类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如： 之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现， 会发现struct中也可以定义函数

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

#define MAX_SIZE 100  // 定义栈的最大容量

// 定义栈结构
typedef struct {
    int data[MAX_SIZE];  // 数组存储栈元素
    int top;             // 记录栈顶索引
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = -1;  // 栈顶初始化为-1，表示空栈
}

// 判断栈是否为空
int isEmpty(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}

// 入栈操作
void push(Stack *s, int value) {
    if (isFull(s)) {
        printf("Stack overflow! Cannot push %d\n", value);
        return;
    }
    s->data[++s->top] = value;
}

// 出栈操作
int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack underflow! Cannot pop\n");
        return -1;  // 返回-1表示错误
    }
    return s->data[s->top--];
}

// 获取栈顶元素
int peek(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty! No top element\n");
        return -1;  // 返回-1表示错误
    }
    return s->data[s->top];
}

// 打印栈元素
void printStack(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty.\n");
        return;
    }
    printf("Stack elements: ");
    for (int i = 0; i <= s->top; i++) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}

// 主函数测试栈
int main() {
    Stack s;
    initStack(&s);

    push(&s, 10);
    push(&s, 20);
    push(&s, 30);
    printStack(&s);

    printf("Top element: %d\n", peek(&s));

    printf("Popped element: %d\n", pop(&s));
    printStack(&s);

    return 0;
}

我们可以看到c语言中结构体只声明了变量，所有的函数都是在结构体之外的。但是在C++中，函数是可以放在结构体中，但是他和c的结构体又有区别，在C++中结构体也被称为类，但是最常用的声明是class而非struct，区别在于默认的函数和变量的默认访问限定符关键字不同。
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分 号不能省略。
 

#include <iostream>

#define MAX_SIZE 100  // 定义栈的最大容量

class Stack {
private:
    int data[MAX_SIZE];  // 用数组存储栈元素
    int top;             // 记录栈顶索引

public:
    // 构造函数：初始化栈
    Stack() {
        top = -1;
    }

    // 判断栈是否为空
    bool isEmpty() {
        return top == -1;
    }

    // 判断栈是否已满
    bool isFull() {
        return top == MAX_SIZE - 1;
    }

    // 入栈操作
    void push(int value) {
        if (isFull()) {
            std::cout << "Stack overflow! Cannot push " << value << std::endl;
            return;
        }
        data[++top] = value;
    }

    // 出栈操作
    int pop() {
        if (isEmpty()) {
            std::cout << "Stack underflow! Cannot pop" << std::endl;
            return -1;  // 返回-1表示错误
        }
        return data[top--];
    }

    // 获取栈顶元素
    int peek() {
        if (isEmpty()) {
            std::cout << "Stack is empty! No top element" << std::endl;
            return -1;  // 返回-1表示错误
        }
        return data[top];
    }

    // 打印栈元素
    void printStack() {
        if (isEmpty()) {
            std::cout << "Stack is empty." << std::endl;
            return;
        }
        std::cout << "Stack elements: ";
        for (int i = 0; i <= top; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

// 主函数测试栈
int main() {
    Stack s;

    s.push(10);
    s.push(20);
    s.push(30);
    s.printStack();

    std::cout << "Top element: " << s.peek() << std::endl;

    std::cout << "Popped element: " << s.pop() << std::endl;
    s.printStack();

    return 0;
}

可以看到类中是包含了函数的，函数是类的一部分。通过实例化对象可以使用其中的函数，这样一来就很方便。

类的访问限定符

 

• public：公开成员，所有地方都可以访问。
• private：私有成员，只能在类内部访问，不允许子类和外部访问。
• protected：受保护成员，子类可以访问，但外部不能访问。

封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来 和对象进行交互。 封装本质上是一种管理，让用户更方便使用类。

比如将类的成员变量设为private，这样外部就无法访问，外部只能访问public修饰的成员函数。

再比如类似的有学习计算机组成原理时，cpu的许多寄存器内容是不可见的，但是状态字寄存器等是可见的。
 

类的作用域

在类的{}中都时类的作用域，在括号外的需要使用：：来声明其从属于哪个类。

#include <iostream>
using namespace std;

class MyClass {
private:
    int value;

public:
    // 在类内部**仅声明**构造函数和成员函数
    MyClass(int v);
    void show();
};

// **在类外定义构造函数**
MyClass::MyClass(int v) {
    value = v;
}

// **在类外定义 show() 方法**
void MyClass::show() {
    cout << "Value: " << value << endl;
}

int main() {
    MyClass obj(10);
    obj.show();  // 输出: Value: 10
    return 0;
}

类的实例化：对象

类可以视为一种声明，声明某个东西所拥有的特点，功能。比如说鸟，是一种概念，声明了这种生物有翅膀，可以飞，眼睛长在头的两侧，嘴被称为喙，是尖的。而各种鸟是这个鸟的概念的实例化，拥有所声明的这些特点。

在代码中的体现是，类声明了拥有什么参数，参数的类型，拥有什么函数，而实例化的对象拥有声明的所有参数函数等等。类的名字不能重复，但是一个类的实例化对象可以有多个，彼此相互独立。

#include <iostream>
using namespace std;

class Car {
private:
    string brand;
    int speed;

public:
    // 构造函数
    Car(string b, int s) {
        brand = b;
        speed = s;
    }

    // 公有方法：获取信息
    void showCar() {
        cout << "Brand: " << brand << ", Speed: " << speed << " km/h" << endl;
    }
};

int main() {
    Car car1("Tesla", 250);
    car1.showCar();  // ✅ 只能通过公有方法访问私有成员

    // car1.brand = "Ford";  // ❌ 编译错误：brand 是 private
    return 0;
}

类的声明本身不占用空间，但是每个实例化的对象都会占用空间，空间互相独立。

对象

计算对象的大小。

如果每个对象包括成员函数和成员变量，那么每有一个对象就需要开辟一块空间，就会造成浪费。

既然使用的都是同一成员函数，那么只需要把成员函数放在单独的空间中，每个对象保存这块空间的地址即可。

只需要计算其中的成员变量的大小即可。因为成员函数被放在一块公有的空间中，所有对象都可以访问。当所有对象都被销毁时，这片空间仍然存在，直到程序运行结束。
 

问题：那么如果一个类没有成员变量，有成员函数或者没有成员函数，那么这个类的大小是多少呢。

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐 注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

this指针

当一个对象调用他的成员函数时，如果这个函数传参传入一个对象，比如进行拷贝构造时，那么如何区分两个对象呢。

这就要用到this指针了，当我们使用 this 指针时，通常它指向当前对象的地址。比如

#include <iostream>
using namespace std;

class MyClass {
public:
    int value;

    // 构造函数
    MyClass(int v) : value(v) {
        cout << "Constructor called, value = " << value << endl;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        cout << "Copy constructor called, copying value from object at " << &other << endl;
        this->value = other.value;  // 使用 this 指针将值复制到当前对象
    }

    // 显示成员变量
    void show() const {
        cout << "Value: " << value << endl;
    }
};

int main() {
    MyClass obj1(10);  // 创建一个对象 obj1
    obj1.show();

    // 使用拷贝构造函数创建新对象 obj2
    MyClass obj2 = obj1;  // 这里会调用拷贝构造函数
    obj2.show();

    return 0;
}

1. 构造函数：
   • 当 obj1 被创建时，调用了普通构造函数，value 被初始化为 10。
2. 拷贝构造函数：
   • 当 obj2 被创建并初始化为 obj1 时，拷贝构造函数被调用。拷贝构造函数接收一个 const MyClass& other 参数，表示我们正在复制的对象。
   • this 指针指向 obj2（新创建的对象），而 other 指向 obj1（被复制的对象）。
   • 我们通过 this->value = other.value 将 obj1 的 value 复制到 obj2 的 value 中。
3. this 指针：
   • this 指针指向当前对象，在拷贝构造函数中，它指向 obj2，即正在初始化的对象。
   • &other 打印出 obj1 的地址，表明拷贝构造函数正在从 obj1 复制数据到 obj2。

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用。

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传 递，不需要用户传递。