很简单的问题，请问c语言里的任意类型的关键字是什么？

sagaeon · 发表于 2004-7-21 23:08:52

[quote:718551bafd="sjinny"]我只记得一个说法是：万能指针[/quote]

的确万能。
ps：突然发现本贴的题目：很简单的问题

。唉，学习吧，不懂的太多了。

做为版猪，这样的讨论技术的贴子是非常值得鼓励的，辩能明理(不要给我改成便能明理

)。同时希望大家真心交流，对别人不懂自己恰好有相关资料时多花点时间给大家讲讲。

kakuyou · 发表于 2004-7-21 23:10:49

[quote:53138badfb="sagaeon"]有些人把void*称为无类型的比如http://www.king.igs.net/~billnacu/wings/csummary.html
但通常称为generic pointer如http://www.eecs.wsu.edu/~cdyreso ... tures/dataTypes.htm及《c语言参考手册》(英)p137。

它的作用似乎类似于动态语言中的无类型变量。

void*的大小《c语言参考手册》p140
:Character and void* pointers can be larger than other kinds of pointers, and they may use a representation that is different from other kinds of pointers........。似乎说明这个长度不是那么明确的是1。而且编程结果是4。[/quote]

上面那个编程的结果没错，但探讨的对象错了
sizeof(struct tty*)
sizeof(FILE*)
sizeof(char*)
sizeof(int*)

上面的结果都是4，问题在于混淆了指针变量本身和它所指向的内存区是两块内存这个概念。

最简单的方法就是编程验证。

char buf[256];
void* p1;
int* p2;

p1= buf;
p2 = (int*)buf;

p1++;
p2++;
打印一下*p1 和 *p2的值，你在
打印一下p1和p2现在的值，你就明白是怎么回事了。

sagaeon · 发表于 2004-7-21 23:47:11

试了，void*不能被解引用。
另，知道你的意思了。你要大家区分开指针这种类型与指针指向对像的类型？

另：p1的内容加了1,表示了它指向的类型的特点(char)，void*指针这个变量本身内容长为4个字节，这点不知楼上赞同不？

kakuyou · 发表于 2004-7-22 00:09:58

[quote:0d493e86e6="sagaeon"]试了，void*不能被解引用。
另，知道你的意思了。你要大家区分开指针这种类型与指针指向对像的类型？

另：p1的内容加了1,表示了它指向的类型的特点(char)，void*指针这个变量本身内容长为4个字节，这点不知楼上赞同不？[/quote]

void*的是用来访问最小内存单元用的，而现代物理内存的最小单元就是1字节，当然32位地址要占4字节保存，因为不论什么指针它本身的值都是一个地址值，所以你写成什么样的*也好，在32位机上都是4字节。

另，如果你还有dos的话，你可以看看dos下的指针是2字节的。

kakuyou · 发表于 2004-7-22 00:48:57

[code:1]
#include <stdio.h>
typedef
struct {
unsigned v11:8;
unsigned v12:8;
unsigned v21:16;
unsigned v22:16;
unsigned v23:16;
unsigned v31:32;
} ptrtest_t __attribute__((packed));

static ptrtest_t ptrtest;

int main(int argc, char** argv)
{
void* p1;
unsigned short* p2;
unsigned int* p3;
int i;

printf ("len of pointor:%d\n", sizeof (void*));
printf ("len of pointor:%d\n", sizeof (unsigned char*));
printf ("len of pointor:%d\n", sizeof (unsigned short*));
printf ("len of pointor:%d\n", sizeof (unsigned int*));
printf ("len of pointor:%d\n", sizeof (ptrtest_t*));
printf ("len of ptrtest_t:%d\n", sizeof (ptrtest_t));
ptrtest.v11 = 0x11;
ptrtest.v12 = 0x22;
ptrtest.v21 = 0x1433;
ptrtest.v22 = 0x1544;
ptrtest.v23 = 0x1766;
ptrtest.v31 = 0x1baa9988;

p1 = &ptrtest;
p2 = (unsigned short*)&ptrtest;

for (i=0; i<12; i++)
printf ("0x%02X ", *((unsigned char*)(p1+i)));
printf ("\n");

printf ("p1=0x%08X\n", p1);
printf ("p2=0x%08X\n", p2);

p1++;
p2++;

printf ("*(p1+1)=0x%08X\n", *((unsigned int*)p1));
printf ("*(p2+1)=0x%08X\n", *((unsigned int*)p2));

printf ("p1=0x%08X\n", p1);
printf ("p2=0x%08X\n", p2);

return 0;
}

[/code:1]

自己试试不同的值吧。

叛逆者.c++ · 发表于 2004-7-24 17:17:16

确实把任何类型转换到void*和把void*转换到任何类型都是可以的
但不能直接使用，都必须显式转换
如果要用动态类型，还使用动态语言吧
否则吃力不讨好

sagaeon · 发表于 2004-7-24 18:31:06

有空我自己再想想，把这个问题搞清楚

leochu · 发表于 2004-7-26 16:05:15

一定是4么？^_^

kakuyou · 发表于 2004-7-26 16:24:22

void*是语法上是万能指针，但不是什么动态类型。看看微软是如何实现通用类型的，编过com程序的人应该会熟悉这个让人不愉快的东东。

[code:1]
typedef struct tagVARIANT VARIANT;
typedef struct tagVARIANT VARIANTARG;
struct tagVARIANT
{
union
      {
      struct __tagVARIANT
         {
         VARTYPE vt;
         WORD wReserved1;
         WORD wReserved2;
         WORD wReserved3;
         union
            {
            LONGLONG llVal;
            LONG lVal;
            BYTE bVal;
            SHORT iVal;
            FLOAT fltVal;
            DOUBLE dblVal;
            VARIANT_BOOL boolVal;
            _VARIANT_BOOL bool;
            SCODE scode;
            CY cyVal;
            DATE date;
            BSTR bstrVal;
            IUnknown *punkVal;
            IDispatch *pdispVal;
            SAFEARRAY *parray;
            BYTE *pbVal;
            SHORT *piVal;
            LONG *plVal;
            LONGLONG *pllVal;
            FLOAT *pfltVal;
            DOUBLE *pdblVal;
            VARIANT_BOOL *pboolVal;
            _VARIANT_BOOL *pbool;
            SCODE *pscode;
            CY *pcyVal;
            DATE *pdate;
            BSTR *pbstrVal;
            IUnknown **ppunkVal;
            IDispatch **ppdispVal;
            SAFEARRAY **pparray;
            VARIANT *pvarVal;
            PVOID byref;
            CHAR cVal;
            USHORT uiVal;
            ULONG ulVal;
            ULONGLONG ullVal;
            INT intVal;
            UINT uintVal;
            DECIMAL *pdecVal;
            CHAR *pcVal;
            USHORT *puiVal;
            ULONG *pulVal;
            ULONGLONG *pullVal;
            INT *pintVal;
            UINT *puintVal;
            struct __tagBRECORD
                  {
                  PVOID pvRecord;
                  IRecordInfo *pRecInfo;
                  } __VARIANT_NAME_4;
            } __VARIANT_NAME_3;
         } __VARIANT_NAME_2;
      DECIMAL decVal;
      } __VARIANT_NAME_1;
struct tagVARIANT
{
union
   {
   struct __tagVARIANT
   {
      VARTYPE vt;
      WORD wReserved1;
      WORD wReserved2;
      WORD wReserved3;
union {
   LONGLONG             llval;          // VT_I8.
   LONG                   lVal;             // VT_I4.
   BYTE                   bVal;             // VT_UI1.
   SHORT                iVal;             // VT_I2.
   FLOAT                fltVal;          // VT_R4.
   DOUBLE                dblVal;          // VT_R8.
   VARIANT_BOOL          boolVal;          // VT_BOOL.
   _VARIANT_BOOL          bool;
   SCODE                scode;          // VT_ERROR.
   CY                   cyVal;          // VT_CY.
   DATE                   date;             // VT_DATE.
   BSTR                   bstrVal;          // VT_BSTR.
   IUnknown             * punkVal;       // VT_UNKNOWN.
   IDispatch             * pdispVal;       // VT_DISPATCH.
   SAFEARRAY             * parray;       // VT_ARRAY|*.
   BYTE                   * pbVal;          // VT_BYREF|VT_UI1.
   SHORT                * piVal;          // VT_BYREF|VT_I2.
   LONG                   * plVal;          // VT_BYREF|VT_I4.
   LONGLONG             * pllVal;       // VT_BYREF|VT_I8.
   FLOAT                * pfltVal;       // VT_BYREF|VT_R4.
   DOUBLE                * pdblVal;       // VT_BYREF|VT_R8.
   VARIANT_BOOL          * pboolVal;       // VT_BYREF|VT_BOOL.
   _VARIANT_BOOL          * pbool;
   SCODE                * pscode;       // VT_BYREF|VT_ERROR.
   CY                   * pcyVal;       // VT_BYREF|VT_CY.
   DATE                   * pdate;          // VT_BYREF|VT_DATE.
   BSTR                   * pbstrVal;       // VT_BYREF|VT_BSTR.
   IUnknown             ** ppunkVal;    // VT_BYREF|VT_UNKNOWN.
   IDispatch             ** ppdispVal;    // VT_BYREF|VT_DISPATCH.
   SAFEARRAY             ** pparray;       // VT_ARRAY|*.
   VARIANT                * pvarVal;       // VT_BYREF|VT_VARIANT.
   PVOID                * byref;          // Generic ByRef.
   CHAR                   cVal;             // VT_I1.
   USHORT                uiVal;          // VT_UI2.
   ULONG                ulVal;          // VT_UI4.
   ULONGLONG             ullVal;          // VT_UI8.
   INT                   intVal;          // VT_INT.
   UINT                   uintVal;          // VT_UINT.
   DECIMAL                * pdecVal       // VT_BYREF|VT_DECIMAL.
   CHAR                   * pcVal;          // VT_BYREF|VT_I1.
   USHORT                * puiVal;       // VT_BYREF|VT_UI2.
   ULONG                * pulVal;       // VT_BYREF|VT_UI4.
   ULONGLONG             * pullVal;       // VT_BYREF|VT_UI8.
   INT                   * pintVal;       // VT_BYREF|VT_INT.
   UINT                   * puintVal;       // VT_BYREF|VT_UINT.
   struct __tagBRECORD
   {
   PVOID                pvRecord;
   IRecordInfo          *pRecInfo;
   } __VARIANT_NAME_4;
} __VARIANT_NAME_3;
  } __VARIANT_NAME_2;
  DECIMAL decVal;
} __VARIANT_NAME_1;

};
};
[/code:1]

serre · 发表于 2004-8-3 00:35:06

C是强类型的，没有你问的那种。

betatoy · 发表于 2004-8-9 02:09:54

C 好像不允許聲明任意類型的變量

		自动登录	找回密码
密码			注册