对malloc的返回值应该如何转型

本文归纳叙述了一篇老文的内容，而且总结对malloc返回值的3种转型方式，（相对于原文）更全面的总结其各自的应用范围。

1. 原文内容
2. 对malloc的3种转型方式
3. 各自的应用范围

 

 

之前有篇文章叫《C/C++ 误区 —— 强制转换 malloc() 的返回值》。
文章大体内容是：

1. malloc函数在<stdlib.h> 或者 <cstdlib>头文件中，而不是<malloc.h>。

2. 因为C语言最初没有void类型，因此是使用char*来表明通用指针。

/*  the old declaration of malloc  */
char *  malloc(size_t size);

char *  p  =  malloc(size  *   sizeof ( * p) );
/*  能够， 不须要转型  */

T1 *  p1  =  malloc(size1  *   sizeof ( * p1) );
/*  (T1!=char) 不能够，char*不能隐式转换成T1*   */

T2 *  p2  =  (T2 * )malloc(size2  *   sizeof ( * p2) );
/*  (T2!=char) 能够，显示类型转换  */

 

3.C语言后来引入了void类型，就可使用void*表明通用指针，同时规定void*能够隐式转换到任意指针类型。

/*  the new declaration of malloc  */
void *  malloc(size_t size);

char *  p  =  malloc(size  *   sizeof ( * p) );
/*  仍然能够，void*能够隐式转换到任意指针类型  */

T1 *  p1  =  malloc(size1  *   sizeof ( * p1) );
/*  如今能够，void*能够隐式转换到任意指针类型  */

T2 *  p2  =  (T1 * )malloc(size2  *   sizeof ( * p2) );
/*  仍然能够，但再也不必须  */

4. 在引入了void以后的C语言中，再使用强制转换是多此一举，同时影响代码维护。
而且说这是一个C/C++的误区。

 

原文概述完毕，开始说本文章的内容：
对malloc返回值的转型，大体有如下三种方式：

 

1. 仅在C中

/* legal only in C */

/* 新头文件 */
T* p = malloc(size * sizeof(*p) ); /* T!=void */

/* 旧头文件 */

T* p = ( T*)malloc(size* sizeof(*p) ); /*  T!= void */

2.仅在C++中
C++自然支持void，可是不容许void*隐式转换到任意类型指针，须要static_cast。

// legal only in C++

// 新头文件
T* p = static_cast<T*>( malloc(size * sizeof(*p) ));

// 旧头文件（目前还有这种编译器吗？）
T* p = reinterpret_cast<T*>( malloc(size * sizeof(*p) ));

// 固然在C++中应该考虑
T* p = new T[size];
// 或者
std::vector<T> p(size);
// 但这不是文章讨论重点

3.在C/C++中

/*  legal in both C and C++  */
/*  legal in both new  and old header  */
T *  p  =  (T * )malloc(size  *   sizeof ( * p) );

 

第1种对新头文件的转型方式，如同代码第1行所说，仅在C编译器中合法。
由于C++不支持void*到其余指针类型的隐式转换。
因此，原文章说这是C/C++的误区，并不许确。
这仅仅是（引入void类型以后的）C语言中的“非必须”的动做，是不是误区，还有待考量。

第2种对新旧头文件的转型方式，代码第1行也说了，仅在C++编译器中合法。

由于C编译器不认识static_cast或者reinterpret_cast。


第3种，是一种中庸的写法。
如同代码第1行所说：此代码不管是在C仍是C++编译器，不管是新头文件仍是旧头文件，都是合法的代码。是可移植性最好的代码。

由于代码中使用的（C风格的）转型、malloc——C／C++都支持。

因此，这种写法并不必定是误区或者多此一举。
由于代码的做者也许比原文章的做者对移植性（C和C++的新旧编译器）考虑更多。

一个排版比较好的原文转载连接
http://programmingart.blog.51cto.com/213782/43503

 

 

学长，问您个很基础的问题，C风格的强制类型转换会触发对应的构造函数么？static_cast和reinterpret_cast会么？另外这两个转换符具体作了些什么？

强制转换都不会触发构造函数。

 

static_cast用于隐式转换的逆过程，如：

short  s;  int  i;
i  =  s;  // 能够，向更宽整数类型进行隐式转换。
s  =  i;  // 警告，向更窄整数类型转换。
s  =  static_cast < short > (i);  // 逆过程，明确代表代码做者的意图，警告消除。

 

base *  b; derived *  d;
b  =  d;  //  能够，向上转型，隐式转换。
d  =  b;  //  错误，向下转型，不容许。
d  =  static_cast < derived *> (b);  //  能够，向上转型的逆过程。但不保证正确。

 

object *  o;  void *  p;
p  =  o;  //  能够，任何指针类型均可以隐式转换到void*
o  =  p;  //  逆过程是错误，除非
o  =  static_cast < object *> (o);  //  能够，但不保证正确

 

 

reinterpret_cast用于整数和指针之间，无继承关系的指针之间的转换。

按照其二进制表示，从新解释( Re- Interpret)，如：

T *  p; intptr_t i;
i  =  reinterpret_cast < intptr_t > (p);
//  将p的地址，解释成一个整数。
p  =  reinterpret_cast < T *> (i);
//  将i的值，解释成一个指向T的指针。

 

T1 *  p1; T2 *  p2;
p1  =  reinterpret_cast < T1 *> (p2);
//  将p2中保存的地址的值，复制到p1。
//  由于p1是T1*类型的指针，之后对p1的操做，将按T1*来解释

//  另一种方式：
p1  =  static_cast < T1 *> ( static_cast < void *> (p2) );

 

若是一个用户自定义类型C， 有一个能够经过单个类型为T的参数进行调用的构造函数， 那么，该构造函数就定义了一个T到C的转换。 若是该构造函数是explicit的，T到C的转换是显式转换。 若是该构造函数不是explicit，T到C的转换是隐式转换。 例如： class string { char* content_; explicit string(const char* source,int length=-1) :content_(0) { if (length==-1) length = static_cast<int>(strlen(source)); content_ = new char[length+1]; strcpy(source,content_); } }; 这个构造函数能够经过单个参数调用（第2个参数有默认值），因此这个构造函数定义了一个 const char* 到 string 的转换。 若是有explicit，那么该转换必须是显式转换： string s = static_cast<string>("hello"); 若是没有explict，该转换能够是隐式转换： string s = "hello"; 上面说错了，这种转换确实会调用构造函数。