当前位置： 首页 > article >正文

C++ 类与对象——超详细入门指南（上篇）

article 2024/10/6 22:35:39

C++ 类与对象——详细入门指南

1. 类的定义

在C++中，类是面向对象编程的基础概念之一。类通过将数据和行为封装在一起，模拟现实世界中的实体。通过类，我们可以定义对象的属性（成员变量）和行为（成员函数）。

1.1 类定义的基本格式

类的定义使用 class 关键字，后面跟上类的名称。在C++中，类体需要用大括号 {} 包裹，并在类定义结束时加上分号 ;。类中的内容称为类的成员，包括：

  • 成员变量：即类的属性，存储类的状态。
  • 成员函数：即类的方法，定义类的行为。
示例代码
#include <iostream>
using namespace std;

class Stack {
public:
    // 成员函数：初始化栈
    void Init(int n = 4) {
        array = (int*)malloc(sizeof(int) * n);
        if (nullptr == array) {
            perror("malloc申请空间失败");
            return;
        }
        capacity = n;
        top = 0;
    }

    // 成员函数：将元素推入栈
    void Push(int x) {
        // 如果栈满，进行扩容
        array[top++] = x;
    }

    // 成员函数：获取栈顶元素
    int Top() {
        assert(top > 0);
        return array[top - 1];
    }

    // 成员函数：销毁栈
    void Destroy() {
        free(array);
        array = nullptr;
        top = capacity = 0;
    }

private:
    // 成员变量：栈的实现细节
    int* array;
    size_t capacity;
    size_t top;
};

int main() {
    Stack st;
    st.Init();
    st.Push(1);
    st.Push(2);
    cout << st.Top() << endl;
    st.Destroy();
    return 0;
}
解释
  • class：定义类的关键字。
  • Stack：类的名称。
  • 成员函数：例如 Init、Push、Top 和 Destroy，它们定义了类的行为。
  • 成员变量：例如 array、capacity、top，这些变量存储类的状态或属性。
  • public/private：访问限定符，决定了类的成员是如何被访问的。public 成员可以在类外访问，private 成员则只能在类内部使用。

1.2 访问限定符

访问限定符是C++实现封装的方式之一，它决定了类的成员能否被类外部的用户访问。

  • public：修饰的成员可以在类外部直接访问。
  • private：修饰的成员只能在类内部访问，类外不能直接访问。
  • protected：类似于 private，但在继承中，子类可以访问 protected 成员。之后会详细讲解
示例代码
class Date {
public:
    // 公有成员函数
    void Init(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }

private:
    // 私有成员变量
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d;
    d.Init(2024, 3, 31);
    return 0;
}
解释
  • public：声明的 Init 函数是公共的，可以在类外部使用。
  • private：_year、_month 和 _day 是私有成员，不能在类外部直接访问，只有类的成员函数能访问这些变量。

1.3 类域

类的作用域决定了类成员的可访问性。在类外定义成员函数时，需要通过作用域解析符 :: 指明成员属于哪个类。例如，如果在类外定义成员函数，需要使用类名和作用域解析符。

示例代码
#include <iostream>
using namespace std;

class Stack {
public:
    void Init(int n = 4);
private:
    int* array;
    size_t capacity;
    size_t top;
};

// 使用作用域解析符在类外定义成员函数
void Stack::Init(int n) {
    array = (int*)malloc(sizeof(int) * n);
    if (nullptr == array) {
        perror("malloc申请空间失败");
        return;
    }
    capacity = n;
    top = 0;
}

int main() {
    Stack st;
    st.Init();
    return 0;
}
解释
  • Stack::Init：:: 作用域解析符表示 Init 函数属于 Stack 类。通过作用域解析符，编译器可以知道该函数属于哪个类，并可以在类的作用域中查找成员变量 array、capacity 和 top。

1.4 成员命名规范

在C++中，通常会为类的成员变量使用特定的命名约定，以避免与函数参数或局部变量混淆。这些命名约定可以提高代码的可读性和维护性。

常见的命名约定：
  1. 使用下划线 _：在成员变量的名称前加一个下划线，以区分成员变量和其他变量。
  2. 使用 m_ 前缀：成员变量以 m_ 开头，表示 “member”（成员变量）。
  3. 驼峰命名法：使用驼峰命名法，例如 myVariable，使得代码更易读。
示例：
class Date {
private:
    int _year;       // 使用下划线前缀
    int m_month;     // 使用 m_ 前缀
    int dayOfMonth;  // 使用驼峰命名法
public:
    void SetDate(int year, int month, int day) {
        _year = year;
        m_month = month;
        dayOfMonth = day;
    }
};
拓展：

这种命名约定并不是C++语言的强制要求，而是遵循公司或团队的编码风格指南。使用这些命名约定可以避免命名冲突，并让代码的意图更加明确。例如，在 SetDate 函数中，使用 _year 和 year 可以轻松区分成员变量和函数参数，减少混淆。

1.5 class与struct的默认访问权限

在C++中，class 和 struct 的区别主要在于默认的访问权限：

  • 在 class 中，未标明的成员变量和成员函数默认是 private。
  • 在 struct 中，未标明的成员变量和成员函数默认是 public。
示例：
struct ExampleStruct {
    int a; // 默认 public
};

class ExampleClass {
    int b; // 默认 private
};

2. 类的实例化

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;
    d1.Init(2024, 3, 31);
    d1.Print();

    Date d2;
    d2.Init(2024, 7, 5);
    d2.Print();

    return 0;
}
解释
  • Date d1：实例化一个 Date 对象 d1。
  • Init：调用 Init 函数初始化 d1 对象的成员变量 _year、_month 和 _day。
  • Print：输出对象的日期信息。

2.2 对象的大小

当类被实例化为对象时，对象的大小取决于类的成员变量。成员变量需要分配空间，但成员函数不会在对象中存储。成员函数是存储在单独的代码段中的一段指令。

示例代码
#include <iostream>
using namespace std;

class A {
private:
    char _ch;  // 1 字节
    int _i;    // 4 字节
};

int main() {
    A a;
    cout << sizeof(a) << endl;  // 输出对象的大小
    return 0;
}
解释
  • 该类的成员变量 _ch 和 _i 总共占用 5 字节，但由于内存对齐，实际对象的大小可能是 8 字节。内存对齐规则保证了访问效率（见下文解释）。

2.3 对象的存储

在C++中，当类被实例化为对象时，只有成员变量会被存储在对象中，而成员函数不会。成员函数是存储在代码段中的一段指令，所有对象共享同一份函数指令。因此，无论类有多少个对象，成员函数只会存在一份。

示例：
class Date {
public:
    void Init(int year, int month, int day);
private:
    int _year;
    int _month;
    int _day;
};

3. this 指针

3.1 什么是 this 指针

this 是C++中的一个隐式指针，存在于每一个非静态成员函数中。this 指针指向调用该成员函数的当前对象。在类的成员函数中，this 指针可以用来访问类的成员变量和成员函数。

  • 当我们在成员函数中使用类的成员变量时，本质上是通过 this 指针访问该成员变量。
  • this 指针是隐含的，C++自动将它传递给所有非静态成员函数。
this 指针的内部机制

在C++中，当类的成员函数被调用时，this 指针会被自动传递给该函数。this 指针的类型是 const Type* const，它是一个只读指针，指向当前对象。你不能修改 this 指针的值，但可以通过 this 访问对象的成员。

3.2 示例代码

#include<iostream>
using namespace std;

class Date {
public:
    void Init(int year, int month, int day) {
        this->_year = year;  // 通过 this 指针访问成员变量
        this->_month = month;
        this->_day = day;
    }

    void Print() {
        cout << _year << "/" << _month << "/" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1;
    d1.Init(2024, 3, 31);
    d1.Print();

    return 0;
}
解释
  • this：在 Init 函数中，this->_year = year 表示将传入的参数 year 赋值给当前对象的 _year 成员变量。this 指针指向当前调用 Init 函数的对象（即 d1）。
拓展解释：this 指针在什么时候使用？

在通常的情况下，编写代码时我们不需要显式使用 this 指针，因为C++会自动处理类的成员和参数之间的冲突。但是在某些情况下，例如当函数的参数名称和成员变量名称相同时，使用 this 指针可以明确地表示成员变量。

void Init(int year, int month, int day) {
    this->_year = year;  // 通过 this 指针区分成员变量和函数参数
    this->_month = month;
    this->_day = day;
}

在上面的代码中，如果不使用 this，编译器会把 year 解释为函数参数，而不是成员变量 _year。

好的，我会在 this 指针部分补充所有的测试内容，并在该部分加入关于 命名 的内容，确保详细且连贯。以下是需要补充的内容：

3.3 this指针的测试题

测试题 1：this 指针的基本行为

#include<iostream>
using namespace std;

class A {
public:
    void Print() {
        cout << "A::Print()" << endl;
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();  // 能否正常运行？
    return 0;
}
问题描述：

我们定义了一个 A 类，包含一个成员函数 Print()，它只是输出一条字符串。我们通过空指针 p 调用 Print() 函数，询问这段代码能否正常运行。

解析：
  1. 在 main() 函数中，A* p = nullptr; 创建了一个指向 A 类的空指针 p。
  2. 随后我们通过空指针 p->Print() 来调用成员函数 Print()，这里的 this 指针其实是空指针。

为什么不会报错？

  • 当我们调用 p->Print() 时，this 指针实际上等于 nullptr，但由于 Print() 函数没有访问任何成员变量，因此C++允许这个调用。
  • this 指针是隐含的，虽然在函数内部会传递 this，但是如果成员函数不访问任何成员变量，C++不需要解引用这个空指针，因此不会出现空指针访问的错误。
  • Print() 函数只是输出了一段固定的文本，不涉及对象的状态或成员变量，因此即使 this 是空指针，也不会导致问题。
正确答案：C. 正常运行

测试题 2：this 指针与成员变量的访问

#include<iostream>
using namespace std;

class A {
public:
    void Print() {
        cout << "A::Print()" << endl;
        cout << _a << endl;
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();  // 能否正常运行？
    return 0;
}
问题描述：

这段代码和前一个问题类似，但在 Print() 函数中多了一个成员变量 _a 的访问。通过空指针 p 调用 Print()，是否会出现空指针访问的问题？

解析：
  1. 在 main() 中，和之前一样，A* p = nullptr; 创建了一个指向 A 类的空指针 p。
  2. 当调用 p->Print() 时，this 指针仍然是 nullptr。

为什么会崩溃？

  • 在 Print() 函数中，除了输出 A::Print() 以外，代码还试图访问类的成员变量 _a。
  • 当 this 指针为 nullptr 时，访问 this->_a 等同于尝试通过空指针访问成员变量。这是一种未定义行为，在大多数系统中会导致程序崩溃。
  • 成员变量 _a 存储在对象的内存空间中，而通过空指针访问成员变量时，由于没有实际的对象空间可用，因此程序在运行时会发生崩溃。
正确答案：B. 运行时崩溃

详细解释：为什么不是空指针访问

在这两个测试题中，关键点在于是否访问了成员变量：

  1. 测试题 1 中，Print() 函数没有访问成员变量，所以即使 this 是空指针，C++也不会触发空指针访问错误。这是因为成员函数本质上只是一个在内存中的函数指针，调用它并不一定需要访问实际对象的内存。

  2. 测试题 2 中，Print() 函数试图访问成员变量 _a。由于成员变量存储在对象的内存空间中，而空指针 this 并没有指向有效的内存区域，所以在运行时会试图通过空指针访问内存，导致程序崩溃。这是典型的空指针访问错误。

总结来说，空指针调用成员函数本身并不会报错，只要该成员函数不涉及访问成员变量或其他依赖对象内存的操作。然而，一旦成员函数试图通过 this 指针访问成员变量，程序就可能会崩溃，因为 this 为 nullptr，没有有效的内存空间可供访问。

测试题 3：this 指针的存储位置

选择题：this 指针存在于内存的哪个区域？

  • A. 栈
  • B. 堆
  • C. 静态区
  • D. 常量区
  • E. 对象里

正确答案：A. 栈

解释：
this 指针作为成员函数的一个隐含参数，存储在栈中。每当一个成员函数被调用时，this 指针会作为函数参数被压入栈中。

4. C++和C语言实现Stack的对比

通过C和C++语言实现 Stack 栈的对比，展现了C++相较于C语言在封装和安全性方面的优势。

4.1 C语言实现Stack

在C语言中，实现 Stack 需要使用 struct 来定义栈的数据结构，并且所有的栈操作（如初始化、压栈、弹栈等）都通过独立的函数实现。由于C语言不支持面向对象编程，数据和操作必须分开处理，所有栈操作的函数需要手动传递 Stack 结构体的指针作为参数。

C语言实现Stack的代码示例
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int STDataType;
typedef struct Stack {
    STDataType* array;
    int top;
    int capacity;
} Stack;

void Init(Stack* s) {
    s->array = (STDataType*)malloc(4 * sizeof(STDataType));
    s->capacity = 4;
    s->top = 0;
}

void Destroy(Stack* s) {
    free(s->array);
    s->array = NULL;
    s->top = 0;
    s->capacity = 0;
}

void Push(Stack* s, STDataType x) {
    if (s->top == s->capacity) {
        s->capacity *= 2;
        s->array = (STDataType*)realloc(s->array, s->capacity * sizeof(STDataType));
    }
    s->array[s->top++] = x;
}

STDataType Top(Stack* s) {
    assert(s->top > 0);
    return s->array[s->top - 1];
}

void Pop(Stack* s) {
    assert(s->top > 0);
    --s->top;
}

bool Empty(Stack* s) {
    return s->top == 0;
}

int main() {
    Stack s;
    Init(&s);
    Push(&s, 1);
    Push(&s, 2);
    printf("栈顶元素: %d\n", Top(&s));
    Pop(&s);
    printf("栈顶元素: %d\n", Top(&s));
    Destroy(&s);
    return 0;
}
C语言实现Stack的详细解释

  • 结构体Stack：这是一个结构体，包含了三个成员：

    • array：一个指向栈的动态数组的指针，用来存储栈中的元素。
    • top：指向栈顶元素的指针，它代表当前栈中元素的个数。
    • capacity：栈的容量，表示栈中最多可以容纳的元素个数。

  • 函数Init：用于初始化栈的大小，并为数组分配内存。C语言中没有构造函数，因此必须通过函数显式初始化结构体。

  • 函数Push：将元素压入栈中，如果栈满则进行扩容操作，使用 realloc 函数为栈分配更大的内存。

  • 函数Top：返回栈顶元素，调用时需要确保栈不为空。

  • 函数Pop：将栈顶元素弹出，减少 top 的值。

  • 内存管理：通过 malloc 和 realloc 动态分配内存，使用 free 释放内存。

4.2 C++语言实现Stack

C++通过类的封装，可以将数据和操作放在一起。栈的实现不仅更为简洁，而且通过封装性提高了代码的安全性和可维护性。相比C语言，C++不需要手动传递 Stack 指针，而是通过类的成员函数自动操作栈。

C++实现Stack的代码示例
#include<iostream>
using namespace std;

class Stack {
public:
    Stack(int n = 4) {
        _array = (int*)malloc(sizeof(int) * n);
        _capacity = n;
        _top = 0;
    }

    ~Stack() {
        free(_array);
        _array = nullptr;
    }

    void Push(int x) {
        if (_top == _capacity) {
            _capacity *= 2;
            _array = (int*)realloc(_array, _capacity * sizeof(int));
        }
        _array[_top++] = x;
    }

    int Top() {
        assert(_top > 0);
        return _array[_top - 1];
    }

    void Pop() {
        assert(_top > 0);
        --_top;
    }

    bool Empty() {
        return _top == 0;
    }

private:
    int* _array;
    size_t _capacity;
    size_t _top;
};

int main() {
    Stack s;
    s.Push(1);
    s.Push(2);
    cout << "栈顶元素: " << s.Top() << endl;
    s.Pop();
    cout << "栈顶元素: " << s.Top() << endl;
    return 0;
}
C++实现Stack的详细解释

  • 构造函数和析构函数：

    • 构造函数 Stack(int n = 4)：用于初始化栈，分配内存并设置栈的容量。这里的 n 是栈的初始大小，默认值为4。构造函数在对象创建时自动调用，确保对象处于有效的状态。
    • 析构函数 ~Stack()：当栈对象被销毁时，自动释放动态分配的内存。这是C++相比C语言的一个显著优势，因为不需要手动调用 Destroy 函数来释放资源。

  • 成员函数Push：与C语言中的 Push 函数类似，用于将元素压入栈中。栈满时会自动扩容，但通过成员函数的封装，这一操作对类外的用户是透明的，用户只需要调用 Push 方法即可。

  • 成员函数Top：返回栈顶元素，和C语言一样，操作之前会检查栈是否为空，保证操作的安全性。

  • 封装性：相比C语言，C++通过类的 private 成员变量 _array、_capacity 和 _top，将栈的实现细节封装起来，防止用户直接操作这些数据。所有的操作都通过 public 成员函数完成，保证了数据的安全性。

拓展解释：构造函数和析构函数（在之后会详细解释）

  • 构造函数：它是类中的特殊函数，当类的对象被创建时，构造函数会被自动调用，用于初始化对象。在 Stack 类中，构造函数初始化栈的容量，并为数组分配内存。

  • 析构函数：它也是类中的特殊函数，当对象生命周期结束（如对象作用域结束时）时，析构函数会自动调用，用于释放对象所占用的资源。在 Stack 类中，析构函数用于释放 malloc 分配的内存，避免内存泄漏。

4.3 C++和C语言实现Stack的对比总结

通过对C和C++实现 Stack 的对比，可以得出以下几点总结：

  • 封装性：C++通过类的封装将数据和操作整合在一起，类的用户不需要关心栈的实现细节，而C语言的实现则需要用户手动调用函数并管理结构体的状态。

  • 内存管理：C语言中，内存管理是手动的，开发者必须显式调用 free 函数释放内存。而在C++中，析构函数自动负责资源的释放，避免了忘记释放内存导致的内存泄漏问题。

  • 安全性：C++中的类通过 private 关键字保护类的内部数据，防止外部代码随意修改类的成员变量，增强了数据的安全性。而C语言没有这种封装机制，所有数据都可以通过结构体直接访问，容易导致意外的修改和错误。

5. 内存对齐

内存对齐是计算机系统中用于优化数据访问的机制。在C++中，类的成员变量在内存中的存放位置要遵循特定的对齐规则，以提高CPU的访问效率。

这部分内容在C语言结构体详细介绍过，详情请见

5.1 内存对齐规则

内存对齐规则规定：

  1. 第一个成员存储在偏移量为0的地址处。

  2. 其他成员必须存储在某个对齐数的整数倍的地址处。

  3. 对齐数取决于编译器的设置和变量的类型，通常为4字节或8字节。

5.2 示例代码

#include<iostream>
using namespace std;

class A {
private:
    char _ch;  // 1 字节
    int _i;    // 4 字节
};

int main() {
    A a;
    cout << "对象 A 的大小: " << sizeof(a) << " 字节" << endl;  // 输出对象大小
    return 0;
}
解释

尽管 A 类中的 _ch 和 _i 变量加起来只有 5 字节，但由于内存对齐规则，类的实际大小为 8 字节。这是因为 int 变量 _i 要求4字节对齐，而 char 只占1字节，因此在 char 后面会插入3个字节的填充空间，以便 int 对齐到4字节边界。

拓展解释：为什么需要内存对齐？

  • 内存对齐的意义：内存对齐的目的是为了优化CPU的读取速度。在现代计算机架构中，处理器一次性读取的内存块大小通常为4字节或8字节。如果数据存储在不对齐的地址上，处理器需要执行更多的操作来读取数据，从而影响性能。因此，通过对齐存储，处理器可以更快速地读取和写入数据。

  • 内存对齐和空间浪费：虽然内存对齐提高了数据访问的效率，但也可能会造成空间浪费。例如，在上例中，char 类型只需要1字节，但为了对齐 int，额外浪费了3个字节的填充空间。这种权衡在性能优化和内存空间利用之间找到了平衡。

5.3 内存对齐的影响

内存对齐会影响类的实际大小。例如，以下代码展示了不同对齐方式下对象的大小变化：

#include<iostream>
#pragma pack(1)  // 设置内存对齐为1字节
using namespace std;

class B {
public:
    char _ch;  // 1字节
    int _i;    // 4字节
};

int main() {
    B b;
    cout << "对象 B 的大小: " << sizeof(b) << " 字节" << endl;  // 输出对象 B 的大小为 5 字节
    return 0;
}
#pragma pack()  // 恢复默认对齐
解释

通过使用 #pragma pack(1) 指令，我们将类 B 的内存对齐设置为 1 字节对齐。这样，char 类型占用 1 字节，int 类型占用 4 字节，总共5字节，没有插入额外的填充字节。


http://www.kler.cn/news/335158.html

相关文章：

  • Java中静态块和构造块
  • Pikachu-Sql-Inject - 通过sql进行远程服务器控制（试验）
  • MongoDB 快速入门+单机部署（附带脚本）
  • 华为OD机试 - Excel单元格数值统计（Python/JS/C/C++ 2024 E卷 200分）
  • git | 合并 commit 的两种方法
  • 没有很深入的理解一下数字图像传感器
  • VL53L4CD液位监测(2)----液位检测
  • 足球青训管理：Spring Boot技术实现
  • 【python实操】python小程序之函数的方法和赋值的区别
  • MySQL 临时表
  • 利用 Qt 和 MySQL 实现简单的数据库用户登录与创建功能
  • Linux 安装 yum
  • 聊聊JIT是如何影响JVM性能的！
  • YOLO11改进|卷积篇|引入SPDConv
  • unity一键注释日志和反注释日志
  • Transformer 模型和 BERT 模型：概述
  • Python机器学习模型的部署与维护：版本管理、监控与更新策略
  • SpringCloudAlibaba的nacos启动注册实现
  • C0007.Clion中添加ui文件及运行的完整步骤
  • MySQL深度分页