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

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

为什么说他万能呢？

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

void型详细介绍

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

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

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

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

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

注意要进行类型转换

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

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

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

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

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

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

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

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

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

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

#include 

// 泛型打印函数
void printValue(void* ptr, const std::string& type) {
    if (type == "int") {
        int* intValue = static_cast(ptr);
        std::cout << "Value: " << *intValue << std::endl;
    } else if (type == "double") {
        double* doubleValue = static_cast(ptr);
        std::cout << "Value: " << *doubleValue << std::endl;
    } else if (type == "char") {
        char* charValue = static_cast(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相结合使用

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

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

代码实例:

#include 

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

// 使用模板元编程实现的通用 Swap 函数
template 
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* 可以实现一定程度上的泛型功能，但由于类型擦除和显式转换等问题，可能存在类型安全性和性能损失。而模板元编程则在编译期间进行类型检查和优化，并提供更好的类型安全性和效率。

最后 C++ void* 在C++24 里面变化不大 modern effective C++ 里面侧重的就是万能和模板的使用

总结： C++里面每一个知识点都对应着一个目的  并且C++是一个不断追求完美的语言 C++三大特性 封装 继承 多态 而模板元编程和模板编程就是多态对应着的一个重要的部分 "万能”等词也都是为多态打下来坚实的代码基础。

好了 本篇文章就到这里 在这里小编想向大家推荐一个课程

https://xxetb.xetslk.com/s/2PjJ3T