void指针

1回顶部
　　热门文章：C++中extern “C”含义深层探索      编程实现盗2005版QQ源码

　　1.概述
　　许多初学者对C/C++语言中的void及void指针类型不甚理解，因此在使用上出现了一些错误。本文将对void关键字的深刻含义进行解说，并详述void及void指针类型的使用方法与技巧。

　　2.void的含义
　　void的字面意思是“无类型”，void *则为“无类型指针”，void *可以指向任何类型的数据。

　　void几乎只有“注释”和限制程序的作用，因为从来没有人会定义一个void变量，让我们试着来定义：

void a;


　　这行语句编译时会出错，提示“illegal use of type ‘void‘”。不过，即使void a的编译不会出错，它也没有任何实际意义。

　　void真正发挥的作用在于：
　　（1） 对函数返回的限定；
　　（2） 对函数参数的限定。

　　我们将在第三节对以上二点进行具体说明。

　　众所周知，如果指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋值；如果p1和p2指向不同的数据类型，则必须使用强制类型转换运算符把赋值运算符右边的指针类型转换为左边指针的类型。 

　　例如：
float *p1;
int *p2;
p1 = p2;


　　其中p1 = p2语句会编译出错，提示“‘=‘ : cannot convert from ‘int *‘ to ‘float *‘”，必须改为：
p1 = (float *)p2;

2回顶部

　　而void *则不同，任何类型的指针都可以直接赋值给它，无需进行强制类型转换：
void *p1;
int *p2;
p1 = p2;


　　但这并不意味着，void *也可以无需强制类型转换地赋给其它类型的指针。因为“无类型”可以包容“有类型”，而“有类型”则不能包容“无类型”。道理很简单，我们可以说“男人和女人都是人”，但不能说“人是男人”或者“人是女人”。下面的语句编译出错：
void *p1;
int *p2;
p2 = p1;


　　提示“‘=‘ : cannot convert from ‘void *‘ to ‘int *‘”。

3.void的使用

　　下面给出void关键字的使用规则：
　　规则一 如果函数没有返回值，那么应声明为void类型

　　在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。但是许多程序员却误以为其为void类型。例如：
add ( int a, int b )
{
return a + b;
}
int main(int argc, char* argv[])
{
printf ( "2 + 3 = %d", add ( 2, 3) );
}


　　程序运行的结果为输出：
　　2 + 3 = 5
　　这说明不加返回值说明的函数的确为int函数。

　　林锐博士《高质量C/C++编程》中提到：“C++语言有很严格的类型安全检查，不允许上述情况（指函数不加类型声明）发生”。可是编译器并不一定这么认定，譬如在Visual C++6.0中上述add函数的编译无错也无警告且运行正确，所以不能寄希望于编译器会做严格的类型检查。

　　因此，为了避免混乱，我们在编写C/C++程序时，对于任何函数都必须一个不漏地指定其类型。如果函数没有返回值，一定要声明为void类型。这既是程序良好可读性的需要，也是编程规范性的要求。另外，加上void类型声明后，也可以发挥代码的“自注释”作用。代码的“自注释”即代码能自己注释自己。
3回顶部

　　规则二 如果函数无参数，那么应声明其参数为void

　　在C++语言中声明一个这样的函数：
int function(void)
{
return 1;
}


　　则进行下面的调用是不合法的：
function(2);


　　因为在C++中，函数参数为void的意思是这个函数不接受任何参数。

　　我们在Turbo C 2.0中编译：
#include "stdio.h"
fun()
{
return 1;
}
main()
{
printf("%d",fun(2));
getchar();
}


　　编译正确且输出1，这说明，在C语言中，可以给无参数的函数传送任意类型的参数，但是在C++编译器中编译同样的代码则会出错。在C++中，不能向无参数的函数传送任何参数，出错提示“‘fun‘ : function does not take 1 parameters”。

　　所以，无论在C还是C++中，若函数不接受任何参数，一定要指明参数为void。

　　规则三 小心使用void指针类型

　　按照ANSI(American National Standards Institute)标准，不能对void指针进行算法操作，即下列操作都是不合法的：
void * pvoid;
pvoid++; //ANSI：错误
pvoid += 1; //ANSI：错误
//ANSI标准之所以这样认定，是因为它坚持：进行算法操作的指针必须是确定知道其指向数据类型大小的。
//例如：
int *pint;
pint++; //ANSI：正确


　　pint++的结果是使其增大sizeof(int)。

　　但是大名鼎鼎的GNU(GNU‘s Not Unix的缩写)则不这么认定，它指定void *的算法操作与char *一致。
4回顶部

　　因此下列语句在GNU编译器中皆正确：
pvoid++; //GNU：正确
pvoid += 1; //GNU：正确


　　pvoid++的执行结果是其增大了1。

　　在实际的程序设计中，为迎合ANSI标准，并提高程序的可移植性，我们可以这样编写实现同样功能的代码：
void * pvoid;
(char *)pvoid++; //ANSI：正确；GNU：正确
(char *)pvoid += 1; //ANSI：错误；GNU：正确


　　GNU和ANSI还有一些区别，总体而言，GNU较ANSI更“开放”，提供了对更多语法的支持。但是我们在真实设计时，还是应该尽可能地迎合ANSI标准。

　　规则四 如果函数的参数可以是任意类型指针，那么应声明其参数为void *

　　典型的如内存操作函数memcpy和memset的函数原型分别为：
void * memcpy(void *dest, const void *src, size_t len);
void * memset ( void * buffer, int c, size_t num );


　　这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论这片内存是什么类型。如果memcpy和memset的参数类型不是void *，而是char *，那才叫真的奇怪了！这样的memcpy和memset明显不是一个“纯粹的，脱离低级趣味的”函数！
5回顶部

　　下面的代码执行正确：
//示例：memset接受任意类型指针
int intarray[100];
memset ( intarray, 0, 100*sizeof(int) ); //将intarray清0

//示例：memcpy接受任意类型指针
int intarray1[100], intarray2[100];
memcpy ( intarray1, intarray2, 100*sizeof(int) ); //将intarray2拷贝给intarray1


　　有趣的是，memcpy和memset函数返回的也是void *类型，标准库函数的编写者是多么地富有学问啊！

　　规则五 void不能代表一个真实的变量

　　下面代码都企图让void代表一个真实的变量，因此都是错误的代码：
void a; //错误
function(void a); //错误


　　void体现了一种抽象，这个世界上的变量都是“有类型”的，譬如一个人不是男人就是女人（还有人妖？）。

　　void的出现只是为了一种抽象的需要，如果你正确地理解了面向对象中“抽象基类”的概念，也很容易理解void数据类型。正如不能给抽象基类定义一个实例，我们也不能定义一个void（让我们类比的称void为“抽象数据类型”）变量。

4.总结
　　小小的void蕴藏着很丰富的设计哲学，作为一名程序设计人员，对问题进行深一个层次的思考必然使我们受益匪浅。

void指针是什么? 

void指针一般被称为通用指针或泛指针，它是C关于“纯粹地址(raw address)”的一种约定。void指针指向某个对象，但该对象不属于任何类型。请看下例：
    int    *ip;
    void    *p;
    在上例中，ip指向一个整型值，而p指向的对象不属于任何类型。
    在C中，任何时候你都可以用其它类型的指针来代替void指针(在C++中同样可以)，或者用void指针来代替其它类型的指针(在C++中需要进行强制转换)，并且不需要进行强制转换。例如，你可以把char *类型的指针传递给需要void指针的函数。
什么时候使用void指针?

当进行纯粹的内存操作时，或者传递一个指向未定类型的指针时，可以使用void指针。void指针也常常用作函数指针。

有些C代码只进行纯粹的内存操作。在较早版本的C中，这一点是通过字符指针(char *)实现的，但是这容易产生混淆，因为人们不容易判断一个字符指针究竟是指向一个字符串，还是指向一个字符数组，或者仅仅是指向内存中的某个地址。

例如，strcpy()函数将一个字符串拷贝到另一个字符串中，strncpy()函数将一个字符串中的部分内容拷贝到另一个字符串中：
    char  *strepy(char‘strl，const char *str2)；
    char  *strncpy(char *strl，const char *str2，size_t n)；   
    memcpy()函数将内存中的数据从一个位置拷贝到另一个位置：
    void  *memcpy(void *addrl，void *addr2，size_t n)；
   
    memcpy()函数使用了void指针，以说明该函数只进行纯粹的内存拷贝，包括NULL字符(零字节)在内的任何内容都将被拷贝。请看下例：
    #include "thingie.h"    /* defines struct thingie */
    struct thingie *p_src，*p_dest；
    /*  ...  */
    memcpy(p_dest，p_src，sizeof(struct thingie) * numThingies)；

在上例中，memcpy()函数要拷贝的是存放在structthingie结构体中的某种对象op_dest和p_src都是指向structthingie结构体的指针，memcpy()函数将把从p_src指向的位置开始的sizeof(stuctthingie) *numThingies个字节的内容拷贝到从p_dest指向的位置开始的一块内存区域中。对memcpy()函数来说，p_dest和p_src都仅仅是指向内存中的某个地址的指针。

void和void指针解析（原）
（一）基本概念
    void 类型：空类型，用于特殊目的的没有操作，也没有值的类型。不能被显式或隐式的转换为任意非空类型，可以通过强制类型转换为void类型。
    void指针：指向任何对象的指针都可以转换为void*类型指针，且不会丢失信息。在ANSI C使用类型void*代替char*作为通用指针的类型。
（二）使用方法
1. void的使用吐舌鬼脸
第一种是：对函数返回的限定
    在不加返回值类型限定的情况之下，编译器会将其处理为整型的类型。例如以下的情况：

#include <stdio.h>
// 参考了别人写void的例子，但是这个例子十分形象
// 的表明了不加返回类型值限定时，编译器的处理规则。
add (int a, int b) 
{ 
    return a + b; 
}
int main(int argc, char* argv[]) 
{ 
    printf("2 + 3 = %d", add (2, 3)); 
    return 0;
}
    对于每个函数，恶魔我们都要明确的指定其返回值的类型。该void的时候，就void。不要省略不写，这回带来大麻烦恶魔。

第二种：对函数参数的限定
    当函数不允许接受参数时，必须使用void限定。例如以下两种情况：
在C语言下：
#include <stdio.h>
// 以下两个函数都可以进行正常的编译，不会报错。
// C的容忍度还是很大的。。。
int func()
{
    return 1;
}
 
int func1(void)
{
    return 1;
}
 
int main(int argc, char* argv[]) 
{ 
    printf("%d\n", func(2)); 
    printf("%d\n", func1(2)); 
    return 0;
} 
运行结果太棒了：
20RQ76LKBLX5_Q_thumb
在C++语言下：
#include <iostream>
int func()
{
    return 1;
}
int func1(void)
{
    return 1;
}
int main(int argc, char* argv[]) 
{ 
    std::cout << func(1) << std::endl;
    std::cout << func1(1) << std::endl;
    return 0;
} 
运行结果哭泣的脸：
7A8_IPQDX6VMHP7O5V2_thumb
    恶魔在C语言中，可以给无参数的函数传送任意类型的参数，但是在C++编译器中编译同样的代码则会出错。恶魔在C++中，不能向无参数的函数传送任何参数。

2. void指针的使用
    在《C++ primer》中，对void指针的作用做了阐述：与另一指针比较；向函数传递void指针或从函数返回void指针；给void指针赋值。
    由于void指针可以指向任意类型的数据，亦即可用任意数据类型的指针对void指针赋值，因此还可以用void指针来作为函数形参，这样函数就可以接受任意数据类型的指针作为参数。

以下摘至sgi stl中的代码片段：吐舌鬼脸

/* __n must be > 0      */
static void* allocate(size_t __n)
{
  void* __ret = 0;
 
  if (__n > (size_t) _MAX_BYTES) {
    __ret = malloc_alloc::allocate(__n);
  }
  else {
    _Obj* __STL_VOLATILE* __my_free_list
        = _S_free_list + _S_freelist_index(__n);
    // Acquire the lock here with a constructor call.
    // This ensures that it is released in exit or during stack
    // unwinding.
    ifndef _NOTHREADS
    /*REFERENCED*/
    _Lock __lock_instance;
    endif
    _Obj* __RESTRICT __result = *__my_free_list;
    if (__result == 0)
      __ret = _S_refill(_S_round_up(__n));
    else {
      *__my_free_list = __result -> _M_free_list_link;
      __ret = __result;
    }
  }
 
  return __ret;
}
/* __p may not be 0 */
static void deallocate(void* __p, size_t __n)
{
  if (__n > (size_t) _MAX_BYTES)
    malloc_alloc::deallocate(__p, __n);
  else {
    _Obj* __STL_VOLATILE*  __my_free_list
        = _S_free_list + _S_freelist_index(__n);
    _Obj* __q = (_Obj*)__p;
 
    // acquire lock
      ifndef _NOTHREADS
    /*REFERENCED*/
    _Lock __lock_instance;
      endif /* _NOTHREADS */
    __q -> _M_free_list_link = *__my_free_list;
    *__my_free_list = __q;
    // lock is released here
  }
}
    对于指针的自增行为，要迎合ANSI C 的规范。在ANSI C中void指针不能自增的，这种行为是一种非法行为，因为未知void的大小。哭泣的脸

#include <iostream>
int main(int argc, char* argv[]) 
{ 
    int i = 0;
    void *p;
    int *pint;
    int *pint1;
    pint = &i;
    p = pint;
    std::cout << pint << std::endl;
    pint++;
    std::cout << pint << std::endl;
    std::cout << p << std::endl;
    pint1 = (int *)p;
    std::cout << pint1 << std::endl;
    return 0;
} 
运行的结果：

9OV3PPIYTPM41KMFY_thumb


文献参考：

1. 《C++ primer》和《C语言程序设计》

2.http://wenku.baidu.com/view/22c4b8d86f1aff00bed51edc.html这篇文章很出名啊太阳，很多void的文章都是转载这一篇文章的。

void指针总结
今天在看memcpy函数原型的时候遇到void指针，我有些地方不明白，就从网上搜集了一些资料，然后总结一下。
先来看下memcpy函数的原型：
void * memcpy ( void * destination, const void * source, size_t num )
我开始以为void指针可以进行应用和计算，出现如下愚蠢的错误：
void * dest,src;
*dest ++= *src++;
知错就改，补习一下指针的知识。
基本概念：“指针”是指地址， 是常量，“指针变量”是指取值为地址的变量。 定义指针的目的是为了通过指针去访问内存单元。
指针有两个属性:指向变量或者对象的地址和长度。但是指针只存储地址,长度则取决于指针的类型 ，编译器根据指针的类型从指针指向的地址向后寻址 指针类型不同则寻址范围也不同。比如: int*从指定地址向后寻找4字节作为变量的存储单元 double*从指定地址向后寻找8字节作为变量的存储单元。
（1）void指针是一种特别的指针。void指针没有特定的类型，因此只知道地址而不能由类型判断出指针所指变量或者对象的长度。
  void * vp;
（2）任何类型的指针都可以赋给void指针。不需要类型转换，vp只是获取地址，并没有获得变量或者对象的长度。
  type * p;
  void* vp = p;
（3）void指针赋值给其他类型的指针时都要进行转换
  void * vp  =pointer; // vp指向一个变量
  type *p = (type*) vp; //类型转换
（4）void指针不能引用
    void * vp  =pointer; // vp指向一个变量
   *vp // 错误的
（5）void指针不能参与指针运算,除非进行转换
void * dest, *src;
*dest ++= *src++;  //错误的
void * vp  =pointer;
(type*)vp++  //进行类型转换后才可以进行指针运算
下面通过memcpy的源码来学习一下void指针的用法，我写memcpy的时候没有考虑内存的重叠，只是简单的逐位拷贝。
void * memcpy ( void * dest, const void * src, size_t n )
{
    if(src == NULL)
    {
        free(dest);
        return NULL;
    }
    if(dest == NULL)
    {
        return NULL;
    }
    if(dest == src)
      return dest;
    size_t count = n;
   char *d = (char*)dest;   //此时进行类型转换，对void指针进行操作
    char *s = (char*)src;
    while(count--)
    {
        *d++ = *s++;    //通过将void指针转换为char*后进行指针运算
    }
    return dest;
}

先介绍下void指针:
其中的第三个参数类型为void指针.我们知道一个指针有两个属性:指向变量或对象的"地址"和"长度".但是指针只存储"地址".
长度则取决于指针的类型.编辑器根据指针的类型从指针的"地址"向后寻址,指针不同,则寻址范围也不同.比如:
int * 从指定地址向后寻址4个字节作为变量的存储单元; double * 则从指定的地址向后寻址8个字节作为变量的存储单元.
1.void指针是特别的指针,因为它没有类型,也就是我们不知道其长度.
    void *vp;
2.任何指针都可以赋值给void指针.
     type *tp;
     vp = tp;//不需要转换.
                 //只获得tp的地址.
3.void指针转赋值给其他类型的指针时需要转换.
    type *tp = (type *)vp;//这样便获得了地址和长度.
4.void指针不能复引用,因为void指针并不知道指针的长度.
    *vp;//错误的
5.void指针不能参加指针运算,除非先对其进行转换.
参:http://www.cppblog.com/dragon/archive/2008/09/02/60760.aspx
---------------------------------------------------------------------------------------------------------------------
下面我们在来看看cocos2d中的:
CCCallFuncND *callFun = [CCCallFuncND actionWithTarget:(id) selector:(SEL) data:(void *)];
 
我们可以看到第三个参数的类型是void指针.
对于obj-c的对象指针来说,可以直接将其作为参数传给data.我们前面的2中说了,任何指针都可以赋值给void指针,但是要注意,丢了类型.
例子1:
NSString *str = @"hello world";
CCCallFuncND *ac =
[CCCallFuncND actionWithTarget:self selector:@selector(move:data:) data:tempString ];
 
- (void)move(id)sender data:(void *)data {
      NSString *str = (NSString *)data;// 我们可以将void指针转换为NSString.
}

例子2:
int t = 100;
CCCallFuncND *ac =
[CCCallFuncND actionWithTarget:self selector:@selector(move:data:) data:(void *)t ];//这里不加一个转换xcode会给出警告.
- (void)move(id)sender data:(void *)data {
      int t = (int)data;//如果不转换xcode会给出警告.
}