如何理解C++中的void*

已于 2023-09-13 12:08:09 修改
阅读量1.1k 收藏 3
点赞数 2
分类专栏： C++ 文章标签： c++
于 2023-09-08 15:41:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33552379/article/details/132755960
版权

1.什么是void*

首先void*中的void代表一个任意的数据类型，"星号"代表一个指针，所以其就是一个任意数据类型的指针。

其实就是一个未指定跳跃力的指针。

那void*的跳跃力又什么时候指定？在需要使用的时候指定就可以了，好处：可以实现泛型编程，节省代码。

对于指定数据类型的指针如int* ，double*等，他们的sizeof都是4个字节，因为都是一个指针，只是指针指向的数据类型不一致。

2.void*使用场景

      2.1：当函数传参是个指针时,不确定数据类型时或者支持多种数据类型传递时。

      2.2：函数返回值不需要考虑类型，只关心返回的大小。

     

 3.void*使用中的注意点：

  1.使用赋值运算符“=”时，void*只能作为左值不能作为右值。

void*作为一个未指定数据类型的指针，可以指向任何一个数据类型的指针，但是有数据类型的指针，不能指向一个void* 的指针。

int i = 5;
int* pi = &i;
void* pv = pi;
int* pi1 = pv;//编译错误，void*类型的指针不能初始化为指定类型的指针
 

 2.void*类型必须强转为指定类型的数据才能使用。

 void*在未指定类型的情况下，是不能直接使用的，只有在转换为显示类型后才能使用。

void*一定要强转为具体指针类型后才能使用. 没有强转的void*是没有意义的。

 int i = 5;
    int* pi = &i;
    void* pv = pi;
     //cout << *pv << endl;//表达式必须是指向完整对象类型的指针
    int*  pip =  (int*)pv;
    cout << " *pip="<<*pip << endl;  // *pip=5

3. 使用(void*)0表示空指针。

  在C语言中空指针定义方式：

  在C语言中NULL代表(void*)0，

#define NULL ((void*)0)

在C++语言中：

在C++中NULL代表的是0，使用nullptr来表示(void*)0空指针，

所以在C++中推荐使用新标准的nullptr来初始化一个空指针。

#ifndef NULL
    #ifdef __cplusplus
        #define NULL 0
    #else 
        #define NULL ((void*)0)
    #endif
#endif
 

4.当void*作为函数的参数类型或者返回值类型时，说明该函数可以接收或者返回任意类型的指针。 

	/*
 void* pVoid 可以使用任意类型的实参指针类型
 返回值也可以返回任意类型的指针
  // 但是 niubiMeth()函数返回值      最终需要转换为具体类型指针才能使用。
 */
void* niubiMeth(void* pVoid) {
    return pVoid;
}


	 double  dou = 11.11;
    double* dp = &dou;
     // 但是 niubiMeth()函数返回值      最终需要转换为具体类型指针才能使用。
    double* resultPDou = static_cast<double *>(niubiMeth(dp));
    double  resultDou = *resultPDou;
    cout <<  "返回的结果 resultPDou ="<<resultPDou<<"  对应的数值resultDou ="<<resultDou << endl;
   //         返回的结果 resultPDou =0x99fec0  对应的数值resultDou =11.11

  

void*在C++中的作用其实就是为了实现泛型编程，和Java中使用Object来表示是一样的，所以又称为通用指针和泛指针，不过C++中大部分情况下会使用模板编程来实现泛型。

	
	//C++中大部分情况下会使用模板编程来实现泛型。
template<typename  T>
T _say(T t) {
    return t;
}
	
int main(){   
  /*
       模板编程不需要将强制转换为具体类型
       未强转也可以直接得出结果，这是因为模板编程会在编译器帮我们生成具体的函数。
       T _say(T t) {return t;}  ->  int* _say(int* t) {return t;}
       */
     int i = 5;
	 int* pi = &i;
     int* resultPI = _say(pi);
     cout << " *resultPI="<<*resultPI<< endl; // *resultPI=5

 float ff = 10.8;
    float* pff = &ff;
    float* resultPff = _say(pff);
    cout << " *resultPff ="<<*resultPff<< endl; //  *resultPff =10.8

}

总结

1.void*是一个过渡型的指针状态，可以代表任意类型的指针，取值的时候需要转换为具体类型才能取值。其是处于数据类型顶端的状态：

2.void* 使用赋值运算符“=”赋值时，只能将具体类型赋值给void星，不能将void*赋值给具体类型。 

3.void*一般作为参数或者返回值来实现泛型编程，但是C++中一般考虑使用模板编程来实现。 

#include <iostream>
using namespace std;


void say(int type, void* pVoid) {
   switch(type){
       case 0:{
           int* pInt = static_cast<int *>(pVoid);
           cout << "转为int类型的指针 pInt=" <<pInt <<" 对应的数值 *pInt="<<*pInt<< endl; //转为int类型的指针 pInt=0x99ff1c 对应的数值 *pInt=9527
           break;
       }

       case 1:{
           float* pFloat = static_cast<float *>(pVoid);
           cout << "转为float类型的指针 pFloat=" <<pFloat <<" 对应的数值 *pFloat="<<*pFloat<< endl;  //转为float类型的指针 pFloat=0x99ff10 对应的数值 *pFloat=23.3333
           break;
       }

       case 2:{
           double* pDouble = static_cast<double *>(pVoid);
           cout << "转为double类型的指针 pDouble=" <<pDouble <<" 对应的数值 *pDouble="<<*pDouble<< endl; //转为double类型的指针 pDouble=0x99ff10 对应的数值 *pDouble=9527.54
           break;

       }
   }


 };


int say2( void* pVoid){
    int* pInt = static_cast<int *>(pVoid);
    cout << "转为int类型的指针 pInt=" <<pInt <<" 对应的数值 *pInt="<<*pInt<< endl;
    //转为int类型的指针 pInt=0x99ff1c 对应的数值 *pInt=9527
   return  *pInt-7;
}

float say22( void* pVoid){
 float* pFloat = static_cast<float *>(pVoid);
 cout << "转为float类型的指针 pFloat=" <<pFloat <<" 对应的数值 *pFloat="<<*pFloat<< endl;
 //转为float类型的指针 pFloat=0x99ff10 对应的数值 *pFloat=23.3333
 return  *pFloat+10;
}








void* say3(int type, void* pVoid) {
    switch(type){
        case 0:{
            int* pInt = static_cast<int *>(pVoid);
            cout << "转为int类型的指针 pInt=" <<pInt <<" 对应的数值 *pInt="<<*pInt<< endl; //转为int类型的指针 pInt=0x99ff1c 对应的数值 *pInt=9527
            return (void*)pInt;
            break;
        }

        case 1:{
            float* pFloat = static_cast<float *>(pVoid);
            cout << "转为float类型的指针 pFloat=" <<pFloat <<" 对应的数值 *pFloat="<<*pFloat<< endl;  //转为float类型的指针 pFloat=0x99ff10 对应的数值 *pFloat=23.3333
            return   (void*)pFloat;
            break;
        }

        case 2:{
            double* pDouble = static_cast<double *>(pVoid);
            cout << "转为double类型的指针 pDouble=" <<pDouble <<" 对应的数值 *pDouble="<<*pDouble<< endl; //转为double类型的指针 pDouble=0x99ff10 对应的数值 *pDouble=9527.54
            return   (void*)pDouble;
            break;

        }
    }
}





/*
 void* pVoid 可以使用任意类型的实参指针类型
 返回值也可以返回任意类型的指针
  // 但是 niubiMeth()函数返回值      最终需要转换为具体类型指针才能使用。
 */
void* niubiMeth(void* pVoid) {
    return pVoid;
}



//C++中大部分情况下会使用模板编程来实现泛型。
template<typename  T>
T _say(T t) {
    return t;
}


int main(){
    int number = 9527;
    say(0,&number);
    int resultInt =  say2(&number);
    cout <<  "返回的结果 resultInt="<<resultInt<< endl; //返回的结果 resultInt=9520

    int* resultPInt = static_cast<int *>(say3(0, &number));
    cout <<  "返回的结果 resultPInt="<<resultPInt<<"  对应的数值*resultPInt="<< *resultPInt << endl;  //返回的结果 resultPInt=0x99ff00  对应的数值*resultPInt=9527


    float f = 70.0/3.0;
    say(1,&f);
    float resultFloat = say22(&f);
    cout <<  "返回的结果 resultFloat="<<resultFloat<< endl;  //返回的结果 resultFloat=33.3333
    float *    resultPFloat = static_cast<float *>(say3(1, &f));
    cout <<  "返回的结果 resultPFloat ="<<resultPFloat<<"  对应的数值*resultPFloat="<< *resultPFloat << endl; //返回的结果 resultPFloat =0x99fef8  对应的数值*resultPFloat=23.3333




    double  d = 9527.54;
    say(2,&d);
    double*   resultPDouble = static_cast<double *>(say3(2, &d));
    cout <<  "返回的结果 resultPDouble ="<<resultPDouble<<"  对应的数值*resultPDouble="<< *resultPDouble << endl; //返回的结果 resultPDou =0x99fed8  对应的数值*resultPDou=11.11



    double  dou = 11.11;
    double* dp = &dou;
     // 但是 niubiMeth()函数返回值      最终需要转换为具体类型指针才能使用。
    double* resultPDou = static_cast<double *>(niubiMeth(dp));
    double  resultDou = *resultPDou;
    cout <<  "返回的结果 resultPDou ="<<resultPDou<<"  对应的数值resultDou ="<<resultDou << endl;
   //         返回的结果 resultPDou =0x99fec0  对应的数值resultDou =11.11




    int i = 5;
    int* pi = &i;
    void* pv = pi;
     //cout << *pv << endl;//表达式必须是指向完整对象类型的指针
    int*  pip =  (int*)pv;
    cout << " *pip="<<*pip << endl;  // *pip=5



      /*
       模板编程不需要将强制转换为具体类型
       未强转也可以直接得出结果，这是因为模板编程会在编译器帮我们生成具体的函数。
       T _say(T t) {return t;}  ->
       int* _say(int* t) {return t;}
       float* _say(float* t) {return t;  }
       */
     int* resultPI = _say(pi);
     cout << " *resultPI="<<*resultPI<< endl; // *resultPI=5

    float ff = 10.8;
    float* pff = &ff;
    float* resultPff = _say(pff);
    cout << " *resultPff ="<<*resultPff<< endl; //  *resultPff =10.8




    return  0;
}

C++小知识02 —— void*
弘羽
05-11 1416
不知道指针类型？那就强转void*。这是C/C++程序员经常遇到的问题，那么void* 到底是什么意思呢，接下来我就和大家说一说他的详解和应用 void在英文词典中译为“空虚、空间、空隙”，而它在C/C++中被翻译为“无类型”，相应的void*则为“无类型指针” void作用 作用1：限定函数返回值的类型 当函数不需要返回值的时候，我们可以用void类型，如下 void fun(int a); 作用2：限定函数参数 当函数不需要参数的时候，我们可以在函数的参数列表中写上void，如下 i
C++中const int * 和 int * const 及void *
weixin_43868436的博客
05-09 1203
#include<iostream> using namespace std; // 可传入任意类型的指针 void* test_void(void* v) { cout << v; //输出地址 cout << *(int *)v; //获取值 int i = 3; int* pi = &i; return pi; //可以返回任意类型指针...
c++中的void*
weixin_33701251的博客
05-09 1333
今天看到一段代码，觉得非常有意思。 void* say_hello(void* args) { cout << "Hello World！" << endl; return 0; } 这里的返回类型竟然是void*。一般来说如果没有返回值，那么写一个void就行了，void*到底是什么样的存在？所以做了一些测试，总结了一些void*指针的...
【C++】详解 void*
Friday
11-08 1195
void*类型的指针其实本质就是一个过渡型的指针状态，必须要赋予类型（强制类型转换）才能正常使用。void *的范围较大，所以强制转换，使其进行范围缩小。只能单向类型转换。void*可以转化成其他类型，但是有类型的不能转化成void*。在函数调用过程中的使用作为输入输出参数也非常好用，可以灵活使用任意类型的指针，避免只能使用固定类型的指针。
C/C++中void与void*详解
热土程序园，利他愉己~
08-09 1648
C/C++中void与void*详解 一.void关键字的使用规则 1.如果函数没有返回值，那么应声明为void类型； 2.如果函数无参数，那么应声明其参数为void； 3.如果函数的参数可以是任意类型指针，那么应声明其参数为void * ； 4.void不能代表一个真实的变量；void体现了一种抽象；
【重学C/C++系列（八）】：如何理解C++中的void*？
yuhaibing111的博客
02-13 1916
首先void*中的void代表一个任意的数据类型，"星号"代表一个指针，所以其就是一个任意数据类型的指针。对于指定数据类型的指针如int* ，double*等，他们的sizeof都是4个字节，因为都是一个指针，只是指针指向的数据类型不一致。C语言是一个强类型的语言，那么他们之间有什么区别呢？前面一篇文章我们说过，指针+1和-1是和指向数据类型有关的。
C++ void指针
TABE_的博客
06-30 785
void* 是一种特殊的指针类型，可用于存放任意对象的地址。一个 void* 指针存放着一个地址，这一点和其他指针类似。 （1）任何类型的指针都可以直接赋值给void指针， 且无需进行强制类型转换 double obj = 3.14, *pd = &obj; void* pv = &obj; // 正确，void* 能存放任意类型对象的地址 // obj 可以是任意类型的对象 pv = pd; //
关于C++中void*的小作用浅析
01-20
本文主要给大家分享了关于C++中void*的一些你可能不了解的小作用，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 先来看一段代码： #include <iostream> #include <string> using namespace std; void o(int* x, void* y){ cout << *x << endl; cout << x << endl; cout << *(int*)y << endl; cout << (int*)y << endl; } int main() { int a = 1, b = 2; o(&a, &
C/C++中的 void*
Nick_Di的博客
06-17 1937
在看《Unix/Linux系统编程》中关于POSIX Thread部分的时候发现C语言中用void*传递了int类型变量，很疑惑，于是差了些资料并汇总了一下。 介绍了C语言和C++中关于void*的用法，涉及到了C++中的reinterpret_cast 如果哪里有错误欢迎指正！ 参考资料 参考资料 1. C/C++中的void*与其他指针类型转换 1.1 C中void*与其他指针类型转换 C语言对指针类型的转换要求很低。但是这将留下一个很大的漏洞 int* a=NULL; void* b=NULL;
如何访问 void* 和 void** 指针类型的数据
Keeplearning
11-30 2057
如何访问 void* 和 void** 指针类型的数据 void* 表示这是一个指针，它指向的对象类型不确定； void** 表示这是一个指针，它指向一个void* 型的指针，这个void *的指针又指向一个不确定类型的对象。 一、如何访问这两种类型的数据呢？ 就是需要先进行强制类型转换，然后再使用 main.cpp #include<iostream> int main(){...
void及void指针含义的深刻解析
我心依旧，明月长歌
08-15 705
转载地址：http://blog.csdn.net/geekcome/article/details/6249151void的含义：    void即“无类型”，void *则为“无类型指针”，可以指向任何数据类型。void指针使用规范：   ①void指针可以指向任意类型的数据，亦即可用任意数据类型的指针对void指针赋值。例如：   int * pint;   void *pvoid;   p...
c++中 void*的使用
Avalon
03-23 2290
说明指针变量包含两个信息，地址和数据的类型。而void*是一种特殊的指针，其只包含地址而不包含类型。 int a; void *vpa = &a; //可以 int *ipa = vpa; //错误，正确方式如下。 int *ipa = (int*)vpa; //可以，强转以后才可以 int b = *vpa; //错误，void*类型不能具体化作用用来传
C/C++中的void 和 void *
ljh0302的专栏
07-28 634
C/C++中的void 和 void * void的含义、作用 void 即“空类型”，不表示“任意类型”。 void 的作用 1）对函数返回的限定：函数不需要返回值 2）对函数参数的限定，函数不允许接受参数 无论在C还是C++中，若函数不接受任何参数，一定要指明参数为void 在C语言中，凡是不加返回值类型限定的函数，就会被编译器作为返回整型值处理，而不是没有返回值。在C++中，
void和void*的用法总结和注意点
阿海的博客
12-14 8555
void和void*的用法总结和注意点
C++ “万能血“ void*指针
m0_74036006的博客
02-06 2380
C++ void* 模板元编程
c++ void*
海涛高软
04-12 231
void指针可以指向任意类型的数据，即可用任意数据类型的指针对void指针赋值 int* aa; void* pp=aa; FR:海涛高软（QQ技术交流群：386476712）
C++中的void*
weixin_42873905的博客
11-21 1770
void的返回值是大家常见的，但是void*呢？ void* say_hello(void* args) { std::cout << "Hello World！" << std::endl; return 0; } 正常来说返回void就可以了，那么我们返回void*到底是什么样的存在呢？ （1）void可以指向任意类型的地址，但是带类型的指针不能指向void的地址 正常来说，如果两个指针类型不一样的话，两个指针变量是不可以直接相等的。例如int* a;float
C/C++中的 void 和 void*
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
01-16 4770
写在前面： 开门见山，大家看下面这个例子： unsigned char err; unsigned char f; unsigned char a(unsigned char i, void *j){ if(j==(void*)0) return 0; *（unsigned char*）j=1; return 1; } void * 就是无类型指针类型，j仅仅...
C++-指针：void*（不确定类型指针）简介【void *可以接受任何类型的赋值】【void *可以赋值给任何类型的变量】【void *不可以解引用】
u013250861的博客
11-22 3123
void*是一种特殊的指针类型，可用于存放任意对象的地址。一个void*指针存放着一个地址，这一点和其他指针类似。简单说一下voidvoidvoid如果函数的参数或返回值可以是任意类型指针，那么应声明其类型为void*；
c++中char *和void *
最新发布
10-10
在 C++ 中，`char*` 和 `void*` 是两种特殊的指针类型： 1. `char*` (指向字符的指针)： - 这是一种通用类型的指针，它可以指向任意单个字节的数据，通常是 ASCII 字符或各种编码的数据单元。当你声明一个 `char*`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值