c++入门----适用于初学者（3）

最新推荐文章于 2024-06-13 23:11:05 发布

善程序员文

最新推荐文章于 2024-06-13 23:11:05 发布

阅读量25

点赞数 1

分类专栏： c++学习文章标签： c++ c语言

本文链接：https://blog.csdn.net/2201_75867204/article/details/132522274

版权

c++学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

内存分配的三种方式

根据内存的分配时机和位置，常见的内存分配方式有以下三种：

静态内存分配（Static Memory Allocation）：静态内存分配是指在编译时期根据程序的静态数据定义来分配内存空间。这种分配方式适用于全局变量、静态变量和静态数组等。静态内存分配的内存空间在程序运行前就被固定下来，并在整个程序的生命周期中保持不变。

静态内存分配的主要优点是访问速度快，分配和释放内存的开销很小。但是，它的缺点是无法灵活地管理内存，分配的内存空间无法根据需要进行动态扩展或缩小。

自动内存分配（Automatic Memory Allocation）：自动内存分配是指在函数调用或代码块执行时，通过栈（stack）上的自动变量来分配内存空间。当函数调用结束或代码块执行完毕时，自动变量的内存空间会自动释放。

自动内存分配是基于栈的分配方式，采用先进后出的原则，具有一定的管理和回收机制。它的主要优点是内存管理相对简单，不容易出现内存泄漏。但由于栈空间有限，不适合存储较大的对象或数据结构。

动态内存分配（Dynamic Memory Allocation）：动态内存分配是指在运行时根据需要动态地分配内存空间。它提供了一种灵活的分配和释放内存的方式，适用于需要动态管理内存的情况。

在 C++ 中，可以使用关键字 new 和 delete 来进行动态内存分配和释放。通过 new 关键字可以在堆（heap）上分配内存空间，而 delete 关键字用于释放之前分配的内存：

int* ptr = new int;  // 动态分配一个整型变量
*ptr = 10;

// 使用动态分配的内存
std::cout << *ptr << std::endl;

delete ptr;  // 释放分配的内存

动态内存分配的主要优点是能够根据实际需求灵活地分配和释放内存，可以动态调整内存大小。但需要注意的是，动态内存分配需要手动管理分配和释放的操作，如果不正确使用会导致内存泄漏或野指针等问题。

不同的内存分配方式各有优缺点，根据具体的需求选择合适的方式进行内存管理是很重要的。

静态存储分配

静态存储分配是指在程序运行期间在编译器决定并固定内存空间的分配方式。它涉及到的变量和对象在程序加载时就被创建，并且一直存在于整个程序的生命周期中。

在 C++ 中，有三种主要的静态存储分配方式：

全局变量：定义在任何函数、类或命名空间之外的变量被认为是全局变量。全局变量在程序开始执行时创建，在程序结束时销毁。全局变量存储在静态数据区，占用固定的内存空间。

int globalVariable = 10;

int main() {
    // 使用全局变量
    std::cout << globalVariable << std::endl;
    return 0;
}

静态变量：静态变量在函数内部声明，在程序运行期间只被初始化一次。它们的生命周期与程序的生命周期相同，但作用范围局限于定义它的函数内部。

void foo() {
    static int staticVariable = 5;

    // 使用静态变量
    std::cout << staticVariable << std::endl;
    staticVariable++;
}

int main() {
    foo();  // 输出: 5
    foo();  // 输出: 6
    return 0;
}

静态成员变量：静态成员变量是属于类的变量，而不是类的对象。它们在类的所有对象之间共享，并且在程序开始执行时创建，在程序结束时销毁。

class MyClass {
public:
    static int staticMember;

    void printStaticMember() {
        // 使用静态成员变量
        std::cout << staticMember << std::endl;
    }
};

int MyClass::staticMember = 20;

int main() {
    MyClass obj1;
    MyClass obj2;

    obj1.printStaticMember();  // 输出: 20
    obj2.printStaticMember();  // 输出: 20

    // 修改静态成员变量
    MyClass::staticMember = 30;

    obj1.printStaticMember();  // 输出: 30
    obj2.printStaticMember();  // 输出: 30

    return 0;
}

静态存储分配的变量和对象在编译时就确定了内存空间，因此其访问速度相对较快。同时，它们具有长时间的生命周期，适用于需要在整个程序中使用的数据和对象。但需要注意的是，滥用全局变量和静态成员变量可能导致代码可读性和可维护性的下降，应谨慎使用。

栈内存分配

栈内存分配是一种自动的、基于栈（stack）的内存分配方式。它用于存储函数调用时所需的局部变量和函数参数等数据。

在程序执行时，每当调用一个函数或进入一个代码块时，系统会为该函数或代码块中的局部变量分配一块栈内存。这些局部变量的内存在函数或代码块执行完毕后会被自动释放，不需要显式地进行内存管理。

栈内存的分配遵循先进后出的原则，即最后分配的变量最先释放。这是因为栈是一种后进先出（LIFO，Last-In-First-Out）的数据结构。每当进入一个新的函数调用或代码块时，系统会将该函数或代码块的局部变量压入栈顶，当函数调用或代码块执行完毕时，这些局部变量会从栈顶弹出，恢复到之前的状态。

栈内存的分配速度非常快，因为仅仅是移动栈指针来分配和释放内存，不涉及复杂的内存管理操作。另外，由于栈内存是自动分配和释放的，不容易出现内存泄漏的问题。

然而，栈内存的大小有限，一般在几兆字节到几百兆字节范围内。当需要分配的栈内存超过了栈的容量时，就会导致栈溢出（Stack Overflow）的错误。因此，在使用栈内存时需要注意变量的大小和栈的容量，避免栈溢出的问题。

下面是一个使用栈内存分配的简单示例：

#include <iostream>

void myFunction(int value) {
    int localVar = value;
    std::cout << "Local Variable: " << localVar << std::endl;
}

int main() {
    int num = 10;
    myFunction(num);
    return 0;
}

在上面的示例中，main() 函数中定义了一个整型变量 num，然后调用了 myFunction() 函数，并将 num 作为参数传递给该函数。myFunction() 函数中有一个局部变量 localVar，它的内存空间将在函数调用时自动分配，并在函数执行完毕后自动释放。

堆内存分配

堆内存分配是一种动态的内存分配方式，用于在运行时分配和释放内存空间。相对于栈内存分配，堆内存的大小没有限制，可以动态地根据需要进行扩展或缩小。

在堆内存分配中，程序员需要显式地申请内存空间，并在不需要使用该内存空间时手动释放它。在 C++ 中，可以使用 new 和 delete 运算符来进行堆内存的分配和释放。

下面是一个简单示例：

#include <iostream>

int main() {
    // 动态分配一个整型变量
    int* ptr = new int;
    *ptr = 10;

    // 使用动态分配的内存
    std::cout << *ptr << std::endl;

    // 释放分配的内存
    delete ptr;

    return 0;
}

在上面的示例中，通过 new 运算符动态地分配了一个整型变量，并将其地址赋值给指针变量 ptr。然后，可以通过指针 ptr 来访问和修改这个动态分配的内存空间。最后，使用 delete 运算符释放了之前分配的内存空间。

需要注意的是，在使用堆内存分配时，应避免内存泄漏（Memory Leak）的问题，即申请了内存空间却忘记释放它。内存泄漏会导致程序消耗过多的内存资源，最终可能导致系统性能下降甚至崩溃。

此外，使用堆内存分配要注意避免野指针（Dangling Pointer）的问题，即释放了内存空间后仍然保留对该内存空间的指针。如果在之后的代码中继续使用该指针，就会访问到无效的内存，可能导致程序崩溃或产生未定义的行为。

因此，在使用堆内存分配时，建议在适当的时候释放已分配的内存空间，并将指针置为 nullptr，以避免悬挂指针（Dangling Pointer）和对已释放内存的非法访问。