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

C++ “万能血“ void*指针

article 2024/11/16 3:32:55

本篇文章我们来介绍一下C++ “万能血” void指针

为什么说他万能呢？

原因:C++ void* 是一种特殊的指针类型，可用于存放任意对象的地址。在函数传参中也可以作为任何实参的形参

void型详细介绍

void* 是C++中的一种特殊的指针类型，被称为"无类型指针"。它可以指向任意类型的数据，但在没有进行类型转换之前，不能直接对其进行解引用操作。

由于 void* 是一个无类型指针，因此它可以用来实现泛型编程或处理未知数据类型的情况。例如，在某些情况下，需要将指针作为参数传递给函数，并且不确定具体的数据类型时，可以使用 void* 类型。

然而，由于 void* 是无类型指针，所以在使用它时需要注意类型安全性。如果要在 void* 指针上执行操作或访问其内容，必须先将其转换回原始类型。

下面我们来看一下代码实例：

int number = 42;
void* ptr = &number; // 将 int 类型的指针赋值给 void*
int* intPtr = static_cast<int*>(ptr); // 将 void* 转换回 int*
std::cout << *intPtr << std::endl; // 解引用 void* 转换后的指针

注意要进行类型转换

万能指针在C++中的应用

“万能“喝“泛型”这两个词语相信大家第一眼看出来就是有很大关联的

在这里先介绍一下C++泛型编程

泛型编程是一种程序设计方法，旨在编写通用、可重用的代码，以处理不同类型的数据，而无需为每个具体类型都创建专门的代码。它使得程序员能够编写与数据类型无关的算法和数据结构，从而提高代码的灵活性和可维护性。

通过使用泛型编程技术，可以将算法或数据结构与特定类型解耦，使其适用于各种不同的数据类型。这种解耦是通过参数化实现的，即在定义函数或类时使用参数来表示待处理的类型。

C++中的模板是实现泛型编程的主要机制之一。通过使用函数模板或类模板，在定义时指定一个或多个类型参数，并在使用时根据需要进行实例化。这样一来，相同的代码可以适用于不同的数据类型。

泛型编程带来了许多优点，包括：

代码复用：可以编写一次通用代码，在多个地方重复使用。
类型安全：在编译时进行类型检查，避免了运行时出现类型错误。
性能优化：由于生成具体化版本时会进行静态展开和优化，因此可以获得与手动针对特定类型优化相似甚至更好的性能。
可扩展性：当需要处理新类型时，只需提供适当的类型参数，而无需修改现有的泛型代码。

总而言之，泛型编程使得程序员能够更加灵活地处理不同类型的数据，并且可以提高代码的可维护性和重用性。

泛型和万能结合的代码实例：

#include <iostream>

// 泛型打印函数
void printValue(void* ptr, const std::string& type) {
    if (type == "int") {
        int* intValue = static_cast<int*>(ptr);
        std::cout << "Value: " << *intValue << std::endl;
    } else if (type == "double") {
        double* doubleValue = static_cast<double*>(ptr);
        std::cout << "Value: " << *doubleValue << std::endl;
    } else if (type == "char") {
        char* charValue = static_cast<char*>(ptr);
        std::cout << "Value: " << *charValue << std::endl;
    } else {
        std::cout << "Unsupported type" << std::endl;
    }
}

int main() {
    int intValue = 42;
    double doubleValue = 3.14;
    char charValue = 'A';

    printValue(&intValue, "int");
    printValue(&doubleValue, "double");
    printValue(&charValue, "char");

    return 0;
}

在上述示例中，通过使用 void* 类型的指针作为参数，我们可以根据不同的类型进行数据打印操作。这样就实现了一种简单的泛型功能。

需要注意的是，在使用 void* 进行泛型编程时，需要小心处理类型转换和指针解引用等操作，以确保类型安全性和正确性。

注意：void*万能指针的解引用通常与C++static_cast<T>相结合使用

拓展： C++ void*和C++模板元编程互相使用

C++模板元编程意思通俗的来说就是编译的时候就执行出结果而不是运行或者说不需要运行就可以出结果了

代码实例:

#include <iostream>

// 使用 void* 实现的通用 Swap 函数
void Swap(void* a, void* b, size_t size) {
    char* first = static_cast<char*>(a);
    char* second = static_cast<char*>(b);
    while (size--) {
        char temp = *first;
        *first++ = *second;
        *second++ = temp;
    }
}

// 使用模板元编程实现的通用 Swap 函数
template <typename T>
void TemplateSwap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    // 使用 void* 的通用 Swap 示例
    int x = 5, y = 10;
    std::cout << "Before swap: x=" << x << ", y=" << y << std::endl;
    Swap(&x, &y, sizeof(int));
    std::cout << "After swap using void*: x=" << x << ", y=" << y << std::endl;

    // 使用模板元编程的通用 Swap 示例
    double p = 2.5, q = 3.7;
    std::cout << "Before swap: p=" << p << ", q=" << q << std::endl;
    TemplateSwap(p, q);
    std::cout << "After swap using templates: p=" << p << ", q=" << q<< std::endl;

   return 0;
}

在上述代码中，我们首先定义了一个使用 void* 实现的通用 Swap 函数，它接受两个 void* 类型的指针和一个表示数据大小的参数。在函数内部，我们将指针转换为 char* 类型，并使用循环逐字节交换数据。

然后，定义了一个使用模板元编程实现的通用 Swap 函数 TemplateSwap，它接受两个模板类型的引用。在函数内部，我们通过创建临时变量并交换值来实现泛型交换操作。

在主函数中，我们分别演示了使用 void* 和模板元编程实现的通用 Swap 函数。可以看到，在使用这两种方法时，不需要关心具体类型，只需传入相应的参数即可完成值的交换。

需要注意的是，虽然使用 void* 可以实现一定程度上的泛型功能，但由于类型擦除和显式转换等问题，可能存在类型安全性和性能损失。而模板元编程则在编译期间进行类型检查和优化，并提供更好的类型安全性和效率。