C++ 指针作为函数参数

C++ 指针作为函数参数

在 C++ 编程中，指针作为函数参数是一项强大且基础的特性，它赋予了程序员更高效灵活地操控数据的能力。理解并熟练运用指针作为函数参数，对于编写高质量、高性能的 C++ 代码至关重要。

指针作为函数参数的基本概念

在 C++ 中，函数参数的传递方式主要有值传递、引用传递和指针传递。当我们使用指针作为函数参数时，实际上是将变量的内存地址传递给了函数。这与值传递形成鲜明对比，值传递是将变量的值复制一份传递给函数，函数对参数的修改不会影响到原始变量。而指针传递允许函数直接访问和修改调用者提供的变量，因为函数操作的是变量的实际内存地址。

例如，我们来看一个简单的示例代码：

#include <iostream>

// 函数声明，接受一个指向 int 类型的指针
void increment(int* num) {
    if (num != nullptr) {
        (*num)++;
    }
}

int main() {
    int value = 5;
    std::cout << "Before increment: " << value << std::endl;
    increment(&value);
    std::cout << "After increment: " << value << std::endl;
    return 0;
}

在上述代码中，increment 函数接受一个 int* 类型的指针 num。在函数内部，通过 (*num)++ 对指针所指向的内存位置的值进行递增操作。在 main 函数中，我们定义了一个 int 类型的变量 value，并将其地址 &value 传递给 increment 函数。这样，increment 函数对 num 的操作实际上影响到了 main 函数中的 value 变量。

指针作为函数参数的优势

1. 直接修改调用者变量 这是指针作为函数参数最显著的优势之一。在许多编程场景中，我们需要函数对传入的变量进行修改，并将修改后的结果反馈给调用者。通过指针传递，函数可以直接操作调用者提供的变量，而无需通过返回值来传递修改后的结果。例如，在一个排序函数中，我们可能希望直接对传入的数组进行排序，而不是返回一个新的已排好序的数组。

#include <iostream>

// 交换两个整数的函数，使用指针作为参数
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10;
    int y = 20;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swap(&x, &y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;
    return 0;
}

在这个 swap 函数中，通过传递两个 int 类型变量的指针，函数能够直接交换这两个变量的值，并且这种修改会反映在 main 函数中。

2. 提高效率 对于大型数据结构，如数组或结构体，如果使用值传递，每次函数调用都需要复制整个数据结构，这会带来巨大的时间和空间开销。而使用指针传递，只需要传递一个内存地址，大大减少了数据复制的开销，提高了程序的运行效率。

#include <iostream>
#include <cstring>

// 结构体定义
struct LargeStruct {
    char data[1000];
};

// 函数声明，接受一个指向 LargeStruct 的指针
void modifyStruct(LargeStruct* largeStruct) {
    if (largeStruct != nullptr) {
        std::strcpy(largeStruct->data, "Modified data");
    }
}

int main() {
    LargeStruct myStruct;
    std::strcpy(myStruct.data, "Original data");
    std::cout << "Before modification: " << myStruct.data << std::endl;
    modifyStruct(&myStruct);
    std::cout << "After modification: " << myStruct.data << std::endl;
    return 0;
}

在上述代码中，LargeStruct 结构体包含一个长度为 1000 的字符数组。如果使用值传递将 LargeStruct 传递给函数，每次调用函数都需要复制 1000 个字符。而通过指针传递，只传递了一个指针的大小（通常在 32 位系统中为 4 字节，64 位系统中为 8 字节），大大提高了效率。

3. 动态内存管理 指针作为函数参数在动态内存管理方面也起着关键作用。当我们在函数内部动态分配内存时，可以通过指针将分配的内存地址传递给调用者，使得调用者能够在合适的时候释放这些内存，避免内存泄漏。

#include <iostream>

// 函数声明，返回一个动态分配的 int 数组
int* createArray(int size) {
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i;
    }
    return arr;
}

int main() {
    int size = 5;
    int* myArray = createArray(size);
    for (int i = 0; i < size; ++i) {
        std::cout << myArray[i] << " ";
    }
    std::cout << std::endl;
    delete[] myArray;
    return 0;
}

在 createArray 函数中，我们动态分配了一个 int 类型的数组，并返回指向该数组的指针。在 main 函数中，我们接收这个指针，并在使用完数组后通过 delete[] 释放内存，确保了动态内存的正确管理。

指针作为函数参数的注意事项

1. 空指针检查 在函数内部，一定要对传入的指针进行空指针检查。如果在空指针上进行解引用操作，会导致程序崩溃。例如，在前面的 increment 函数中，我们使用了 if (num != nullptr) 来检查指针是否为空，只有在指针不为空的情况下才进行解引用操作。

#include <iostream>

// 函数声明，接受一个指向 int 类型的指针
void increment(int* num) {
    if (num == nullptr) {
        std::cerr << "Error: Null pointer passed." << std::endl;
        return;
    }
    (*num)++;
}

int main() {
    int* nullPtr = nullptr;
    increment(nullPtr);
    return 0;
}

在上述代码中，如果不进行空指针检查，调用 increment(nullPtr) 会导致程序崩溃。通过添加空指针检查，我们可以使程序更加健壮，避免这种运行时错误。

2. 指针生命周期管理 当通过指针传递动态分配的内存时，必须清楚地知道内存的所有权和生命周期。如果多个函数都持有指向同一块动态分配内存的指针，并且每个函数都认为自己有权释放内存，就会导致多次释放同一块内存的错误，即双重释放错误。同样，如果没有任何函数负责释放内存，就会导致内存泄漏。

#include <iostream>

// 函数声明，接受一个指向 int 类型的指针并释放内存
void releaseMemory(int* ptr) {
    if (ptr != nullptr) {
        delete ptr;
    }
}

int main() {
    int* dynamicInt = new int(10);
    releaseMemory(dynamicInt);
    // 错误：这里再次尝试释放已经释放的内存
    releaseMemory(dynamicInt);
    return 0;
}

在上述代码中，releaseMemory 函数释放了 dynamicInt 指向的内存。之后再次调用 releaseMemory(dynamicInt) 会导致双重释放错误。为了避免这种情况，可以使用智能指针来自动管理动态内存的生命周期。

#include <iostream>
#include <memory>

// 函数声明，接受一个 std::unique_ptr<int> 并释放内存
void releaseMemory(std::unique_ptr<int> ptr) {
    // 这里 std::unique_ptr 会自动管理内存释放
}

int main() {
    std::unique_ptr<int> dynamicInt = std::make_unique<int>(10);
    releaseMemory(std::move(dynamicInt));
    // 此时 dynamicInt 不再拥有内存，不会导致双重释放
    return 0;
}

在这个改进的代码中，std::unique_ptr 自动管理内存的释放，避免了双重释放错误。

3. 指针类型匹配 函数调用时传递的指针类型必须与函数参数期望的指针类型完全匹配。如果类型不匹配，会导致编译错误。例如：

#include <iostream>

// 函数声明，接受一个指向 int 类型的指针
void increment(int* num) {
    if (num != nullptr) {
        (*num)++;
    }
}

int main() {
    double value = 5.5;
    // 错误：不能将 double* 转换为 int*
    increment((int*)&value);
    return 0;
}

在上述代码中，increment 函数期望一个 int* 类型的指针，但我们试图传递一个 double* 类型的指针，即使进行了强制类型转换，这种做法也是不安全的，可能会导致未定义行为。正确的做法是确保传递的指针类型与函数参数类型一致。

多级指针作为函数参数

在 C++ 中，我们不仅可以使用一级指针作为函数参数，还可以使用多级指针。多级指针在处理复杂的数据结构，如二维数组或链表的链表时非常有用。

1. 二级指针作为函数参数 二级指针是指向指针的指针。当我们需要在函数内部修改一个指针的值时，就需要使用二级指针。例如，考虑一个动态分配二维数组的场景：

#include <iostream>

// 函数声明，接受一个二级指针来创建二维数组
void create2DArray(int**& arr, int rows, int cols) {
    arr = new int*[rows];
    for (int i = 0; i < rows; ++i) {
        arr[i] = new int[cols];
        for (int j = 0; j < cols; ++j) {
            arr[i][j] = i * cols + j;
        }
    }
}

// 函数声明，释放二维数组的内存
void release2DArray(int**& arr, int rows) {
    for (int i = 0; i < rows; ++i) {
        delete[] arr[i];
    }
    delete[] arr;
    arr = nullptr;
}

int main() {
    int** my2DArray;
    int rows = 3;
    int cols = 4;
    create2DArray(my2DArray, rows, cols);
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << my2DArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    release2DArray(my2DArray, rows);
    return 0;
}

在 create2DArray 函数中，我们接受一个 int**& 类型的参数 arr。这里使用 & 是因为我们需要在函数内部修改 arr 指针本身，使其指向动态分配的二维数组。如果不使用二级指针，我们无法在函数内部改变 my2DArray 的值，只能改变它所指向的内存中的值。

2. 多级指针的注意事项 使用多级指针时，代码的复杂度会显著增加，因为我们需要更加小心地管理指针的层级关系和内存分配与释放。例如，在释放多级指针所指向的内存时，必须按照正确的顺序进行释放，否则会导致内存泄漏或未定义行为。同时，多级指针的可读性较差，在编写和维护代码时需要格外谨慎。

指针与数组作为函数参数的关系

在 C++ 中，数组名在大多数情况下会被隐式转换为指向数组首元素的指针。这意味着我们可以将数组名作为指针传递给函数。

#include <iostream>

// 函数声明，接受一个 int 数组（实际是指向 int 的指针）
void printArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    int size = sizeof(myArray) / sizeof(myArray[0]);
    printArray(myArray, size);
    return 0;
}

在上述代码中，printArray 函数接受一个 int 数组作为参数，实际上传递的是指向数组首元素的指针 myArray。在函数内部，我们可以像使用指针一样操作数组。

需要注意的是，当数组作为函数参数传递时，数组的大小信息会丢失。因此，我们需要额外传递一个参数来表示数组的大小。另外，虽然数组名和指针在这种情况下有相似的行为，但它们并不是完全相同的概念。数组有自己的固定内存布局和大小，而指针只是一个内存地址。

指针作为函数参数与 const 关键字

1. 使用 const 修饰指针参数 我们可以使用 const 关键字来修饰指针参数，以表明函数不会修改指针所指向的内容。这有助于提高代码的安全性和可读性。

#include <iostream>

// 函数声明，接受一个指向 const int 的指针
void printValue(const int* num) {
    if (num != nullptr) {
        std::cout << "Value: " << *num << std::endl;
    }
}

int main() {
    int value = 10;
    printValue(&value);
    return 0;
}

在上述代码中，printValue 函数接受一个 const int* 类型的指针 num。这意味着函数不能通过 num 修改其所指向的 int 类型变量的值。如果在函数内部尝试修改 *num，会导致编译错误。

2. const 指针参数与非 const 指针参数的区别 当函数有多个重载版本，一个接受 const 指针参数，另一个接受非 const 指针参数时，编译器会根据传递的实参是否为 const 来选择合适的函数版本。

#include <iostream>

// 函数声明，接受一个指向 const int 的指针
void printValue(const int* num) {
    if (num != nullptr) {
        std::cout << "Const version: Value: " << *num << std::endl;
    }
}

// 函数声明，接受一个指向 int 的指针
void printValue(int* num) {
    if (num != nullptr) {
        std::cout << "Non - const version: Value: " << *num << std::endl;
        (*num)++;
    }
}

int main() {
    int value = 10;
    const int constValue = 20;
    printValue(&value);
    printValue(&constValue);
    return 0;
}

在上述代码中，当我们传递 &value 时，会调用非 const 版本的 printValue 函数，因为 value 不是 const 类型。而当我们传递 &constValue 时，会调用 const 版本的 printValue 函数，因为 constValue 是 const 类型，只能匹配 const int* 类型的参数。

指针作为函数参数在面向对象编程中的应用

在 C++ 的面向对象编程中，指针作为函数参数也有广泛的应用。例如，在类的成员函数中，经常会使用指针来操作对象的数据成员或与其他对象进行交互。

#include <iostream>

class MyClass {
private:
    int data;
public:
    MyClass(int value) : data(value) {}
    // 成员函数，接受一个 MyClass* 指针并进行操作
    void addValue(MyClass* other) {
        if (other != nullptr) {
            data += other->data;
        }
    }
    void printData() {
        std::cout << "Data: " << data << std::endl;
    }
};

int main() {
    MyClass obj1(5);
    MyClass obj2(10);
    obj1.addValue(&obj2);
    obj1.printData();
    return 0;
}

在上述代码中，MyClass 类的 addValue 成员函数接受一个 MyClass* 类型的指针 other。通过这个指针，addValue 函数可以访问另一个 MyClass 对象的数据成员，并进行相应的操作。

此外，在多态和虚函数的实现中，指针也起着关键作用。通过基类指针指向派生类对象，我们可以在运行时根据对象的实际类型调用相应的虚函数，实现多态行为。

#include <iostream>

class Base {
public:
    virtual void print() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived class" << std::endl;
    }
};

// 函数声明，接受一个 Base* 指针并调用 print 函数
void printObject(Base* obj) {
    if (obj != nullptr) {
        obj->print();
    }
}

int main() {
    Base baseObj;
    Derived derivedObj;
    printObject(&baseObj);
    printObject(&derivedObj);
    return 0;
}

在上述代码中，printObject 函数接受一个 Base* 类型的指针 obj。当我们传递 &baseObj 时，会调用 Base 类的 print 函数；当我们传递 &derivedObj 时，由于多态性，会调用 Derived 类的 print 函数。

通过以上对 C++ 指针作为函数参数的详细介绍，我们深入了解了指针作为函数参数的概念、优势、注意事项以及在不同编程场景中的应用。熟练掌握这一特性，将有助于我们编写出更高效、灵活且健壮的 C++ 代码。无论是在简单的数值计算，还是复杂的面向对象编程和大型项目开发中，指针作为函数参数都是 C++ 程序员不可或缺的工具。