【1】ptr = malloc(0*sizeof(char))【2】关于typedef的用法总结【3】关于有符号数、无符号数和数据类型的总结 .

ptr = malloc(0*sizeof(char));（转载）

最近，看了有关malloc(0)的返回值以及其他一些问题的讨论，我把自己的感受和看法记录如下：

问题：char* ptr = malloc(0*sizeof(char));

if(NULL == ptr)

      printf("got a NULL pointer");

else

     printf("got a Valid pointer");

请问：上面的程序输出为什么？在C99的标准里面解释到，如果给malloc传递0参数，其返回值是依赖于编译器的实现，但是不管返回何值，该指针指向的对象是不可以访问的。在VC6编译环境下，输出“got a Valid pointer”

但是我试图给该指针赋值，如：*ptr = ''a'' ;编译器并没有给出任何错误和警告信息，接着，我再输出该值，printf("*ptr=%d\n",*ptr) ;也可以正常输出。

但是当我用free(ptr) ;释放内存的时候，出现错误，为什么呢？下面是我看了网友经过讨论以后我比较认同的看法：

当malloc分配内存时它除了分配我们指定SIZE的内存块，还会分配额外的内存来存储我们的内存块信息，用于维护该内存块。因此，malloc（0）返回一个合法的指针并指向存储内存块信息的额外内存，我们当然可以在该内存上进行读写操作，但是这样做了会破坏该内存块的维护信息，因此当我们调用free(ptr)时就会出现错误。完整程序如下：

#include 
#include

int main()
{
 char *ptr ;
 ptr = malloc(0*sizeof(char)) ;
 
 if (NULL == ptr)
  printf("got a NULL pointer\n");
 else 
 {
  printf("got a Valid pointer\n");

  *ptr = ''a'
  printf("the value at %X is:%c\n",ptr,*ptr);

  free(ptr) ;//if we did not add this statement ,the program can run normnlly，or we will get 

// a runtime error.
 }
 return 0 ;
}

既然malloc另外分配内存来维护该内存块，也就是说分配来用于维护该内存块的内存的大小也是有限的，那么到底是多少呢？这和可能也依赖于实现，在VC6下，是56BYTE,下面是测试程序：

#include 
#include 
#include

int main()
{
 char *ptr ;
 ptr = malloc(0*sizeof(char)) ;
 
 if (NULL == ptr)
  printf("got a NULL pointer\n");
 else 
 {
  printf("got a Valid pointer\n");
  // 有56个a，另外有一个字节用于保存''\0'
  strcpy(ptr,"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); 
  //printf("the value at %X is:%c\n",ptr,*ptr);
  printf("the string at %x is :%s\n",ptr, ptr);
 // free(ptr);
 }
 return 0 ;
}

此时我们没有把free（ptr）编译进来，同样会发生异常，程序输出很多个56个a,我暂时还不明白为什么？？？？？如果把free(ptr);编译进来，就会发生运行错误！

通过上面的讨论和程序的验证，确实证明了网友和我的想法是正确的，也就是malloc(0)还会额外分配一部分空间（在VC6下是56字节）用于维护内存块。

兄弟们可以运行下上面的程序，愿意的话帮我把为什么输出很多个56个a出来这个问题解决掉！^_^我感激不尽。

关于typedef的用法总结

    不管实在C还是C++代码中，typedef这个词都不少见，当然出现频率较高的还是在C代码中。typedef与#define有些相似，但更多的是不同，特别是在一些复杂的用法上，就完全不同了，看了网上一些C/C++的学习者的博客，其中有一篇关于typedef的总结还是很不错，由于总结的很好，我就不加修改的引用过来了，以下是引用的内容(红色部分是我自己写的内容)。

用途一：

定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如：

char* pa, pb; // 这多数不符合我们的意图，它只声明了一个指向字符变量的指针，

// 和一个字符变量；

以下则可行：

typedef char* PCHAR;

PCHAR pa, pb;  

这种用法很有用，特别是char* pa, pb的定义，初学者往往认为是定义了两个字符型指针，其实不是，而用typedef char* PCHAR就不会出现这样的问题，减少了错误的发生。

用途二:
用在旧的C代码中，帮助struct。以前的代码中，声明struct新对象时，必须要带上struct，即形式为： struct 结构名对象名，如：

struct tagPOINT1

 {
    int x;

    int y; 
};

struct tagPOINT1 p1;

而在C++中，则可以直接写：结构名对象名，即：tagPOINT1 p1;

typedef struct tagPOINT
{
    int x;

    int y;
}POINT;

POINT p1; // 这样就比原来的方式少写了一个struct，比较省事，尤其在大量使用的时

候,或许，在C++中，typedef的这种用途二不是很大，但是理解了它，对掌握以前的旧代

码还是有帮助的，毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。

用途三：

用typedef来定义与平台无关的类型。

比如定义一个叫 REAL 的浮点类型，在目标平台一上，让它表示最高精度的类型为：

typedef long double REAL;

在不支持 long double 的平台二上，改为：

typedef double REAL;

在连 double 都不支持的平台三上，改为：

typedef float REAL;

也就是说，当跨平台时，只要改下 typedef 本身就行，不用对其他源码做任何修改。

标准库就广泛使用了这个技巧，比如size_t。另外，因为typedef是定义了一种类型的新别名，不是简单的字符串替换，所以它比宏来得稳健。
     这个优点在我们写代码的过程中可以减少不少代码量哦！

用途四：

为复杂的声明定义一个新的简单的别名。方法是：在原来的声明里逐步用别名替换一部

分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化

版。举例： 

 原声明：void (*b[10]) (void (*)());

变量名为b，先替换右边部分括号里的，pFunParam为别名一：

typedef void (*pFunParam)();

再替换左边的变量b，pFunx为别名二：

typedef void (*pFunx)(pFunParam);

原声明的最简化版：

pFunx b[10];
 
原声明：doube(*)() (*e)[9];

变量名为e，先替换左边部分，pFuny为别名一：

typedef double(*pFuny)();

再替换右边的变量e，pFunParamy为别名二

typedef pFuny (*pFunParamy)[9];

原声明的最简化版：

pFunParamy e;

理解复杂声明可用的“右左法则”：从变量名看起，先往右，再往左，碰到一个圆括号

就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直

到整个声明分析完。举例：

int (*func)(int *p);

首先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针

；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*func)是一个函数，所以

func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值

类型是int。

int (*func[5])(int *);

func右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明

func的元素是指针（注意这里的*不是修饰func，而是修饰func[5]的，原因是[]运算符

优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数

组的元素是函数类型的指针，它指向的函数具有int*类型的形参，返回值类型为int。

这种用法是比较复杂的，出现的频率也不少，往往在看到这样的用法却不能理解，相信以上的解释能有所帮助。

*****以上为参考部分，以下为本人领悟部分*****

使用示例：

1.比较一：

#include <iostream>

using namespace std;

typedef int (*A) (char, char);

int ss(char a, char b)
{
    cout<<"功能1"<<endl;

    cout<<a<<endl;

    cout<<b<<endl;

    return 0;
}
 
int bb(char a, char b)
{

    cout<<"功能2"<<endl;

    cout<<b<<endl;

    cout<<a<<endl;

    return 0;

}

void main()
{

    A a;

    a = ss;

    a('a','b');

    a = bb;

    a('a', 'b');
}

2.比较二：

typedef int (A) (char, char);

void main()
{

    A *a;

    a = ss;

    a('a','b');

    a = bb;

    a('a','b');
}
 

两个程序的结果都一样：

功能1

a

b

功能2

b

a

 

*****以下是参考部分*****

参考自：http://blog.hc360.com/portal/personShowArticle.do?articleId=57527

typedef 与 #define的区别：

案例一：

通常讲，typedef要比#define要好，特别是在有指针的场合。请看例子：

typedef char *pStr1;

#define pStr2 char *;

pStr1 s1, s2;

pStr2 s3, s4;
在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们

所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一

个类型起新名字。

案例二：

下面的代码中编译器会报一个错误，你知道是哪个语句错了吗？

typedef char * pStr;

char string[4] = "abc";

const char *p1 = string;

const pStr p2 = string;

p1++;

p2++;

　　是p2++出错了。这个问题再一次提醒我们：typedef和#define不同，它不是简单的

文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和

const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类

型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数

据类型为char *的变量p2为只读，因此p2++错误。虽然作者在这里已经解释得很清楚了，可我在这个地方仍然还是糊涂的，真的希望哪位高手能帮忙指点一下，特别是这一句“只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已”，难道自己定义的类型前面用const修饰后，就不能执行更改运算，而系统定义的类型却可以？

关于有符号数、无符号数和数据类型的总结

 一、

  CPU只会根据输入信号进行逻辑运算，在硬件级别是没有有符号无符号的概念，运算结束会根据运算前的信号和输出信号来设置一些标志位，是不是有符号由写程序的人决定，标志位要看你把操作数当有符号还是无符号来选择，就像内存中的数据，你可以按照需要来解析，原始数据在那里，你要按什么数据格式来解析在于自己的选择，所以玩汇编的要做到心里有数，加减法只有一套指令，因为这一套指令同时适用于有符号和无符号。下面这些指令：mul div movzx … 是处理无符号数的，而这些：imul idiv movsx … 是处理有符号的。举例来说：
内存里有 一个字节x 为：0x EC ，一个字节 y 为：0x 02 。当把x，y当作有符号数来看时，x = -20 ，y = +2 。当作无符号数看时，x = 236 ，y = 2 。下面进行加运算，用 add 指令，得到的结果为：0x EE ，那么这个 0x EE 当作有符号数就是：-18 ，无符号数就是 238 。所以，add 一个指令可以适用有符号和无符号两种情况。（呵呵，其实为什么要补码啊，就是为了这个呗，:-)）
乘法运算就不行了，必须用两套指令，有符号的情况下用imul 得到的结果是：0x FF D8 就是 -40 。无符号的情况下用 mul ，得到：0x 01 D8 就是 472 。

二、

C又是可怕的，因为它把机器层面的所有的东西都反应了出来，像这个有没有符号的问题就是一例（java就不存在这个问题，因为它被设计成所有的整数都是有符号的）。为了说明c的可怕特举一例：
#include <stdio.h>
#include <string.h>

int main()
{
        int x = 2;
        char * str = "abcd";
        int y = (x - strlen(str) ) / 2;
       
        printf("%d\n",y);
}
结果应该是 -1 但是却得到：2147483647 。为什么?因为strlen的返回值，类型是size_t，也就是unsigned int ，与 int 混合计算时类型被自动转换了，结果自然出乎意料。。。
观察编译后的代码，除法指令为 div ，意味无符号除法，即将-2看做无符号数了。
解决办法就是强制转换，变成 int y = (int)(x - strlen(str) ) / 2; 强制向有符号方向转换（编译器默认正好相反），这样一来，除法指令编译成 idiv 了。我们知道，就是同样状态的两个内存单位，用有符号处理指令 imul ，idiv 等得到的结果，与用无符号处理指令mul，div等得到的结果，是截然不同的！所以牵扯到有符号无符号计算的问题，特别是存在讨厌的自动转换时，要倍加小心！（这里自动转换时，无论gcc还是cl都不提示！！！）
为了避免这些错误，建议，凡是在运算的时候，确保你的变量都是 signed 的。

三、自动类型转化时的，短字节向长字节转化时，有符号数会符号扩展，无符号数会0扩展；长字节向短字节转化时，会自动截取高位，留下低位字节。特别在做算术运算时，比如乘除法，就可能涉及到有符号数自动转化为无符号数，从而采用不同的指令处理。

例如：下面的代码输出是什么，为什么？

void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
    这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ”>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式 计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

四。特别注意在有常数的算数表达式中，往往有隐含的数据类型转化，因为整数常量并没有明确的被指出其的数据类型，

整常数在不加特别说明时总是正值。如果需要的是负值，则负号“-”必须放置于常数表达式的前面。

每个常数依其值要给出一种类型。当整常数应用于一表达式时，或出现有负号时，常数类型自动执行相应的转换，十进制常数可等价于带符号的整型或长整型，这取决于所需的常数的尺寸。

八进制和十六进制常数可对应整型、无符号整型、长整型或无符号长整型，具体类型也取决于常数的大小。如果常数可用整型表示，则使用整型。如果常数值大于一个整型所能表示的最大值，但又小于整型位数所能表示的最大数，则使用无符号整型。同理，如果一个常数比无符号整型所表示的值还大，则它为长整型。如果需要，当然也可用无符号长整型。

但是，可以在一个常数后面加一个字母l或L强制其数据类型，则认为是长整型。如1 0 L、7 9 L、0 1 2 L、0 11 5 L、0 X A L、0 x 4 f L等。

L, U, LU,叫类型后缀,.  一般在程序中出现3种数据.我把它们叫,变量,常量,字面量.
变量,常量一般都已经规定了类型了的,所以后缀针对的是字面量.
由于语言默认,整数是int型.即字面量 12 是 int型的.
如果要表示 长整型的12 就得加后缀 12L,无符号的 12U,无符号长整型的12UL.
具体这些有什么用,你需要了解整数在内存中的存放形式...存放长度(位)...