C语言基本数据类型及其扩展和可移植性问题

最新推荐文章于 2022-09-16 00:07:31 发布
最新推荐文章于 2022-09-16 00:07:31 发布
阅读量3.7k 收藏 11
点赞数 2
分类专栏： c/c++ 文章标签： c语言 数据 扩展 移植 标准
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014659656/article/details/46779381
版权

不同的c标准，基本数据类型大同小异，但基本都会包括以下几种：

一定含有 char 、short 、int 、long 、float 、double

可能含有long int、long long、long double

甚至还有复数类型float_Complex、double_Complex、long double_Complex

                                      Float_Imaginary、double_Imaginary、longdouble_Imaginary

 

下面我们介绍最基本的char 、short 、int 、long 、float 、double

其中char、short、int、long都可以用unsigned和signed修饰来表示有符号和无符号，缺省默认是signed

 

那每种数据类型占用的存储空间是多少呢?答案是不确定的。不同的系统上面位数都不一样。

可以采用sizeof(type)来获得自己机器上各种数据类型位数

例如我的compad320的位数（单位是字节）

#include<stdio.h>
int main(void){
	printf("char length: %d\n",sizeof(char));
	printf("short length: %d\n",sizeof(short));
	printf("int length: %d\n",sizeof(int));
	printf("long length: %d\n",sizeof(long));
	printf("long int length: %d\n",sizeof(long int));
	printf("float length: %d\n",sizeof(float));
	printf("double length: %d\n",sizeof(double));
	return 0;
}

char length: 1

short length: 2

int length: 4

long length: 4

long int length: 4

float length: 4

double length: 8

所以不确定就会带来一些问题，比如你写的程序里面的数据长度都要求是固定的，int 32位，long64位，但是移植到不同的机器上后，可能int是16位，long是32位，这就会出问题。

可不可以在声明类型的时候就指明是多少位呢？比如int32 就作为一种类型，这里就可以在头文件中用typedef定义自己的类型，程序都同意使用自己定义的数据类型，从而在移植程序的时候，只用根据不同的系统来修改类型定义头文件即可。

例如可以在自己的机器上定义出int32

Typedef signed int int32;(因为signed int在本机器上是32位的)

另外需要注意的问题就是如果你自己定义了基本类型，那么printf和scanf在格式化输出的时候还需要做相应的处理，因为不同数据类型对应着不同的输出类型。例如格式化输出long

就需要%ld。所以你还必须定义自己的格式化输出符，可以采用串宏的方法

如：typedef short int16;就该对应定义#define PRId16 “hd”

然后int16 me16;printf(“me16=%”PRId16”\n”,me16);该句经过宏替换后就形成printf(“me16=%””hd””\n”,me16);而C语言默认将三个连续的字符串合并成一个引号一起来的字符串，最后就变成printf(“me16=%hd\n”,me16);从而按正确的格式输出int16类型的数据

 

自己定义的可能比较麻烦，好在C语言还有扩展数据类型，在inttypes.h头文件中。但这个都需要编译器的支持，不同的编译器可能用法不一样。

 

C99中引入了stdint.h和inttypes.h，对整数类型的定义和格式转换进行了规范。这种扩展整数类型的定义非常清晰，从类型名字上就可以看出它的长度，这有利于编写可移植的代码。stint.h对整数类型进行定义，inttypes.h包含了stdint.h并增加了可移植的格式控制串和转换函数。


 1、stdint.h： 定义标准的扩展整数类型。包括准确长度类型intN_t、最小长度类型int_leastN_t、快速长度类型int_fastN_t、指针长度类型intptr_t、最大长度类型intmax_t（N为类型宽度）。
    定义规则：
    1）类型的长度用宽度N参数化，如intN_t，N常常有8,16,32,64。
    2）若要定义某种类型，则该类型的带符号和无符号类型、类型长度都要定义。如定义int32_t，则有uint32_t类型。
    3）要用...MIN和...MAX宏定义类型的范围。如INT32_MIN,INT32_MAX,UINT32_MAX。
    4）在inttypes.h要用PRIcKN和SCNcKN定义打印该类型的printf和scanf格式控制字符串。c表示转换操作符，有d,i,o,u,x或X；K表示种类，为空或者LEAST,FAST,PTR,MAX；N是该类型的宽度。

/* ISO C99: 7.18 整数类型 <stdint.h>  */
#ifndef _STDINT_H
#define _STDINT_H	1
#include <features.h>
#include <bits/wchar.h>
#include <bits/wordsize.h>
/* 准确类型：指定长度的准确类型  */
/* 有符号  */
/* 有一些与<sys/types.h>中众所周知的inet代码重叠 */
#ifndef __int8_t_defined
# define __int8_t_defined
typedef signed char		int8_t; /* 8位的准确长度类型int8_t=signed char */
typedef short int		int16_t; /* 16位的准确长度类型 */
typedef int			int32_t;
# if __WORDSIZE == 64 
typedef long int		int64_t;  /*  64位平台上64位的准确类型为long */
# else
__extension__
typedef long long int		int64_t; /*  32位平台上64位的准确类型为long long */
# endif
#endif
/* 无符号  */
typedef unsigned char		uint8_t;
typedef unsigned short int	uint16_t;
#ifndef __uint32_t_defined
typedef unsigned int		uint32_t;
# define __uint32_t_defined
#endif
#if __WORDSIZE == 64
typedef unsigned long int	uint64_t;
#else
__extension__
typedef unsigned long long int	uint64_t;
#endif

/* 最小类型：指定长度的最小类型  */
/* 有符号  */
typedef signed char		int_least8_t;
typedef short int		int_least16_t;
typedef int			int_least32_t;
#if __WORDSIZE == 64
typedef long int		int_least64_t;
#else
__extension__
typedef long long int		int_least64_t;
#endif
/* 无符号  */
typedef unsigned char		uint_least8_t;
typedef unsigned short int	uint_least16_t;
typedef unsigned int		uint_least32_t;
#if __WORDSIZE == 64
typedef unsigned long int	uint_least64_t;
#else
__extension__
typedef unsigned long long int	uint_least64_t;
#endif

/* 快速类型：指定长度的最快类型  */
/* 有符号  */
typedef signed char		int_fast8_t;
#if __WORDSIZE == 64       /* 64位平台 */
typedef long int		int_fast16_t;
typedef long int		int_fast32_t;
typedef long int		int_fast64_t;
#else     /* 32位平台 */
typedef int			int_fast16_t; /* 16位和32位的最快类型均为int */
typedef int			int_fast32_t;
__extension__
typedef long long int		int_fast64_t;
#endif
/* 无符号  */
typedef unsigned char		uint_fast8_t;
#if __WORDSIZE == 64
typedef unsigned long int	uint_fast16_t;
typedef unsigned long int	uint_fast32_t;
typedef unsigned long int	uint_fast64_t;
#else
typedef unsigned int		uint_fast16_t;
typedef unsigned int		uint_fast32_t;
__extension__
typedef unsigned long long int	uint_fast64_t;
#endif

/* 通用指针类型：即void * 型指针的类型，64位平台上为long，32位平台上为int  */
#if __WORDSIZE == 64
# ifndef __intptr_t_defined
typedef long int		intptr_t;
#  define __intptr_t_defined
# endif
typedef unsigned long int	uintptr_t;
#else
# ifndef __intptr_t_defined
typedef int			intptr_t;
#  define __intptr_t_defined
# endif
typedef unsigned int		uintptr_t;
#endif

/* 最大类型：指定长度的最大整数类型  */
#if __WORDSIZE == 64
typedef long int		intmax_t;  /* 64位平台上的最大整数类型为long */
typedef unsigned long int	uintmax_t;
#else
__extension__
typedef long long int		intmax_t;  /* 32位平台上的最大整数类型为long long */
__extension__
typedef unsigned long long int	uintmax_t;
#endif
/* ISO C99标准指出，在C++实现中这些宏应该只在被请求到的时候才定义 */
#if !defined __cplusplus || defined __STDC_LIMIT_MACROS
# if __WORDSIZE == 64
#  define __INT64_C(c)	c ## L
#  define __UINT64_C(c)	c ## UL
# else
#  define __INT64_C(c)	c ## LL
#  define __UINT64_C(c)	c ## ULL
# endif
/* 整数类型的范围  */
/* 有符号整数类型的最小值：-2**(N-1)，其中最小负数-2**(N-1)=100...0没有对应正数，其反数还是自己  */
# define INT8_MIN		(-128)
# define INT16_MIN		(-32767-1)
# define INT32_MIN		(-2147483647-1)
# define INT64_MIN		(-__INT64_C(9223372036854775807)-1)
/* 有符号整数类型的最大值：2**(N-1)-1  */
# define INT8_MAX		(127)
# define INT16_MAX		(32767)
# define INT32_MAX		(2147483647)
# define INT64_MAX		(__INT64_C(9223372036854775807))
/* 无符号整数类型的最大值：2**(N-1)-1，注意有Min=-MAX-1  */
# define UINT8_MAX		(255)
# define UINT16_MAX		(65535)
# define UINT32_MAX		(4294967295U)
# define UINT64_MAX		(__UINT64_C(18446744073709551615))

/* 有符号最小类型的最小值  */
# define INT_LEAST8_MIN		(-128)
# define INT_LEAST16_MIN	(-32767-1)
# define INT_LEAST32_MIN	(-2147483647-1)
# define INT_LEAST64_MIN	(-__INT64_C(9223372036854775807)-1)
/* 有符号最小类型的最大值  */
# define INT_LEAST8_MAX		(127)
# define INT_LEAST16_MAX	(32767)
# define INT_LEAST32_MAX	(2147483647)
# define INT_LEAST64_MAX	(__INT64_C(9223372036854775807))
/* 无符号最小类型的最大值  */
# define UINT_LEAST8_MAX	(255)
# define UINT_LEAST16_MAX	(65535)
# define UINT_LEAST32_MAX	(4294967295U)
# define UINT_LEAST64_MAX	(__UINT64_C(18446744073709551615))

/* 有符号快速类型的最小值  */
# define INT_FAST8_MIN		(-128)
# if __WORDSIZE == 64
#  define INT_FAST16_MIN	(-9223372036854775807L-1)
#  define INT_FAST32_MIN	(-9223372036854775807L-1)
# else
#  define INT_FAST16_MIN	(-2147483647-1)
#  define INT_FAST32_MIN	(-2147483647-1)
# endif
# define INT_FAST64_MIN		(-__INT64_C(9223372036854775807)-1)
/* 有符号快速类型的最大值  */
# define INT_FAST8_MAX		(127)
# if __WORDSIZE == 64
#  define INT_FAST16_MAX	(9223372036854775807L)
#  define INT_FAST32_MAX	(9223372036854775807L)
# else
#  define INT_FAST16_MAX	(2147483647)
#  define INT_FAST32_MAX	(2147483647)
# endif
# define INT_FAST64_MAX		(__INT64_C(9223372036854775807))
/* 无符号快速类型的最大值  */
# define UINT_FAST8_MAX		(255)
# if __WORDSIZE == 64
#  define UINT_FAST16_MAX	(18446744073709551615UL)
#  define UINT_FAST32_MAX	(18446744073709551615UL)
# else
#  define UINT_FAST16_MAX	(4294967295U)
#  define UINT_FAST32_MAX	(4294967295U)
# endif
# define UINT_FAST64_MAX	(__UINT64_C(18446744073709551615))

/* 指针类型（持有void*型指针）的范围  */
# if __WORDSIZE == 64
#  define INTPTR_MIN		(-9223372036854775807L-1)
#  define INTPTR_MAX		(9223372036854775807L)
#  define UINTPTR_MAX		(18446744073709551615UL)
# else
#  define INTPTR_MIN		(-2147483647-1)
#  define INTPTR_MAX		(2147483647)
#  define UINTPTR_MAX		(4294967295U)
# endif

/* 有符号最大类型的最小值  */
# define INTMAX_MIN		(-__INT64_C(9223372036854775807)-1)
/* 符号最大类型的最大值  */
# define INTMAX_MAX		(__INT64_C(9223372036854775807))
/* 无符号最大类型的最大值 */
# define UINTMAX_MAX		(__UINT64_C(18446744073709551615))

/* 其他整数类型的范围  */
/* ptrdiff_t类型的范围  */
# if __WORDSIZE == 64
#  define PTRDIFF_MIN		(-9223372036854775807L-1)
#  define PTRDIFF_MAX		(9223372036854775807L)
# else
#  define PTRDIFF_MIN		(-2147483647-1)
#  define PTRDIFF_MAX		(2147483647)
# endif
/* sig_atomic_t类型的范围  */
# define SIG_ATOMIC_MIN		(-2147483647-1)
# define SIG_ATOMIC_MAX		(2147483647)
/* size_t类型的范围  */
# if __WORDSIZE == 64
#  define SIZE_MAX		(18446744073709551615UL)
# else
#  define SIZE_MAX		(4294967295U)
# endif
/* wchar_t类型的范围  */
# ifndef WCHAR_MIN
/* 这些常量可能在<wchar.h>也定义了  */
#  define WCHAR_MIN		__WCHAR_MIN
#  define WCHAR_MAX		__WCHAR_MAX
# endif
/* wint_t类型的范围  */
# define WINT_MIN		(0u)
# define WINT_MAX		(4294967295u)
#endif	/* C++ && limit macros */
/* ISO C99标准指出，在C++实现中这些宏应该只在被请求到的时候才定义 */
#if !defined __cplusplus || defined __STDC_CONSTANT_MACROS
/* 有符号  */
# define INT8_C(c)	c
# define INT16_C(c)	c
# define INT32_C(c)	c
# if __WORDSIZE == 64
#  define INT64_C(c)	c ## L
# else
#  define INT64_C(c)	c ## LL
# endif
/* 无符号  */
# define UINT8_C(c)	c
# define UINT16_C(c)	c
# define UINT32_C(c)	c ## U
# if __WORDSIZE == 64
#  define UINT64_C(c)	c ## UL
# else
#  define UINT64_C(c)	c ## ULL
# endif
/* 最大类型  */
# if __WORDSIZE == 64
#  define INTMAX_C(c)	c ## L
#  define UINTMAX_C(c)	c ## UL
# else
#  define INTMAX_C(c)	c ## LL
#  define UINTMAX_C(c)	c ## ULL
# endif
#endif	/* C++ && constant macros */
#endif /* stdint.h */

解释：
    （1）准确长度类型：具有准确长度，没有填充位，在stdint.h是可选的。类型intN_t, uintN_t，范围INTN_MIN, INTN_MAX, UINTN_MAX，inttypes.h中的控制字符串PRIcN, SCNcN。
    最小长度类型：具有指定长度的最小类型，至少要对N=8,16,32,64定义这些类型。宏INTN_C(constant), UINTN_C(constant)用于把传进来的常数扩展成相应类型的常量(即在后面加常量修饰符，如U,L,LL,ULL)。
    快速长度类型：具有指定最小长度的最快类型。至少要对N=8,16,32,64定义这些类型。
    指针长度类型：intptr_t, uintptr_t，分别是带符号和无符号整数类型，可以放置任何对象指针。范围INTPTR_MIN, INTPTR_MAX, UINTPTR_MAX。
    最大长度类型：intmax_t, uintmax_t，最大带符号和无符号整数类型，所有C语言实现都要定义。宏INTMAX_C(), UINTMAX_C()用于把传进来的常数扩展成相应类型的常量。
    （2）GNU实现中，各种扩展整数类型与我们通常使用的整数类型长度一致，即8位使用char类型，16位使用sort类型，32位使用int类型，64位在64位平台使用long类型，在32位平台上使用long long类型，注意32平台上的long一般和int一样大。只有快速类型有点区别，在32位平台上，16位和32位快速类型均使用int（这样才能快速地按字寻址），64位快速类型使用long long；在64位平台上，16位、32位和64位快速类型均使用long。最大类型与字长度一致，指针类型也与字长度一致。
    （3）有符号整数范围为-2**(N-1)~2**(N-1)-1，其中最小负数-2**(N-1)=100...0没有对应正数，其反数还是自己。无符号整数类型范围为0~2**N-1。
    （4）ptrdiff_t,size_t,wchar_t,wint_t与sig_atomic_t类型的范围也在stdint.h中定义，有PTRDIFF_MIN/PTRDIFF_MAX, SIZE_MAX,  WCHAR_MIN/WCHAR_MAX,WINT_MIN/WINT_MAX, SIG_ATOMIC_MIN/SIG_ATOMIC_MAX。在32位平台的GNU实现中，ptrdiff_t一般为int类型（在64位平台上则为long类型），size_t为unsignedint类型（在64位平台上则为unsigned long类型），wchar_t一般为int类型，wint_t一般为unsigned int类型，sig_atomic_t通常为int类型。
   

 2、inttypes.h： 定义扩展整数类型的printf和scanf格式控制字符串，用于实现可移植的格式化输出或输入。还定义了一些与stdlib.h中对应的基本算术函数和转换函数。imaxabs和imaxdiv函数类似于stdlib.h中的abs和div函数，imaxabs(x)返回最大类型整数x的绝对值，imaxdiv(n,d)计算最大类型整数的除法n/d，得出的商和余数分别放在imaxdiv_t结构的quot和rem成员中。strtoimax和strtoumax函数将字符串转换成最大类型的整数，与stdlib.h中的strtol和strtoul类似。wcstoimax和wcstoumax函数将宽字符串转换成最大类型的整数，与wchar.h中的wcstol和wcstoul类似。

/* ISO C99: 7.8  整数类型的格式转换	 <inttypes.h>  */
#ifndef _INTTYPES_H
#define _INTTYPES_H	1
#include <features.h>
/* 获取类型定义  */
#include <stdint.h>
/* 获取wchar_t的定义，但我们自己不能定义  */
#ifndef ____gwchar_t_defined
# ifdef __cplusplus
#  define __gwchar_t wchar_t
# elif defined __WCHAR_TYPE__
typedef __WCHAR_TYPE__ __gwchar_t;
# else
#  define __need_wchar_t
#  include <stddef.h>
typedef wchar_t __gwchar_t;
# endif
# define ____gwchar_t_defined	1
#endif
/* ISO C99标准指出，这些宏应该只在被请求到的时候才定义 */
#if !defined __cplusplus || defined __STDC_FORMAT_MACROS
# if __WORDSIZE == 64
#  define __PRI64_PREFIX	"l"
#  define __PRIPTR_PREFIX	"l"
# else
#  define __PRI64_PREFIX	"ll"
#  define __PRIPTR_PREFIX
# endif
/* 表示输出格式控制串的宏  */
/* 十进制格式  */
# define PRId8		"d"  /* 表示8位准确类型的输出格式控制串 */
# define PRId16		"d"
# define PRId32		"d"
# define PRId64		__PRI64_PREFIX "d"
# define PRIdLEAST8	"d"    /* 表示8位最小类型的输出格式控制串 */
# define PRIdLEAST16	"d"
# define PRIdLEAST32	"d"
# define PRIdLEAST64	__PRI64_PREFIX "d"
# define PRIdFAST8	"d"
# define PRIdFAST16	__PRIPTR_PREFIX "d"
# define PRIdFAST32	__PRIPTR_PREFIX "d"
# define PRIdFAST64	__PRI64_PREFIX "d"
# define PRIi8		"i"
# define PRIi16		"i"
# define PRIi32		"i"
# define PRIi64		__PRI64_PREFIX "i"
# define PRIiLEAST8	"i"
# define PRIiLEAST16	"i"
# define PRIiLEAST32	"i"
# define PRIiLEAST64	__PRI64_PREFIX "i"
# define PRIiFAST8	"i"
# define PRIiFAST16	__PRIPTR_PREFIX "i"
# define PRIiFAST32	__PRIPTR_PREFIX "i"
# define PRIiFAST64	__PRI64_PREFIX "i"
/* 八进制格式  */
# define PRIo8		"o"
# define PRIo16		"o"
# define PRIo32		"o"
# define PRIo64		__PRI64_PREFIX "o"
# define PRIoLEAST8	"o"
# define PRIoLEAST16	"o"
# define PRIoLEAST32	"o"
# define PRIoLEAST64	__PRI64_PREFIX "o"
# define PRIoFAST8	"o"
# define PRIoFAST16	__PRIPTR_PREFIX "o"
# define PRIoFAST32	__PRIPTR_PREFIX "o"
# define PRIoFAST64	__PRI64_PREFIX "o"
/* 无符号整数格式  */
# define PRIu8		"u"
# define PRIu16		"u"
# define PRIu32		"u"
# define PRIu64		__PRI64_PREFIX "u"
# define PRIuLEAST8	"u"
# define PRIuLEAST16	"u"
# define PRIuLEAST32	"u"
# define PRIuLEAST64	__PRI64_PREFIX "u"
# define PRIuFAST8	"u"
# define PRIuFAST16	__PRIPTR_PREFIX "u"
# define PRIuFAST32	__PRIPTR_PREFIX "u"
# define PRIuFAST64	__PRI64_PREFIX "u"
/* 小写十六进制格式  */
# define PRIx8		"x"
# define PRIx16		"x"
# define PRIx32		"x"
# define PRIx64		__PRI64_PREFIX "x"
# define PRIxLEAST8	"x"
# define PRIxLEAST16	"x"
# define PRIxLEAST32	"x"
# define PRIxLEAST64	__PRI64_PREFIX "x"
# define PRIxFAST8	"x"
# define PRIxFAST16	__PRIPTR_PREFIX "x"
# define PRIxFAST32	__PRIPTR_PREFIX "x"
# define PRIxFAST64	__PRI64_PREFIX "x"
/* 大写十六进制格式  */
# define PRIX8		"X"
# define PRIX16		"X"
# define PRIX32		"X"
# define PRIX64		__PRI64_PREFIX "X"
# define PRIXLEAST8	"X"
# define PRIXLEAST16	"X"
# define PRIXLEAST32	"X"
# define PRIXLEAST64	__PRI64_PREFIX "X"
# define PRIXFAST8	"X"
# define PRIXFAST16	__PRIPTR_PREFIX "X"
# define PRIXFAST32	__PRIPTR_PREFIX "X"
# define PRIXFAST64	__PRI64_PREFIX "X"
/* 打印intmax_t和uintmax_t的格式宏  */
# define PRIdMAX	__PRI64_PREFIX "d"
# define PRIiMAX	__PRI64_PREFIX "i"
# define PRIoMAX	__PRI64_PREFIX "o"
# define PRIuMAX	__PRI64_PREFIX "u"
# define PRIxMAX	__PRI64_PREFIX "x"
# define PRIXMAX	__PRI64_PREFIX "X"

/* 打印intptr_t和uintptr_t的格式宏  */
# define PRIdPTR	__PRIPTR_PREFIX "d"
# define PRIiPTR	__PRIPTR_PREFIX "i"
# define PRIoPTR	__PRIPTR_PREFIX "o"
# define PRIuPTR	__PRIPTR_PREFIX "u"
# define PRIxPTR	__PRIPTR_PREFIX "x"
# define PRIXPTR	__PRIPTR_PREFIX "X"
/* 表示输入格式控制串的宏  */
/* 有符号十进格式  */
# define SCNd8		"hhd"
# define SCNd16		"hd"
# define SCNd32		"d"
# define SCNd64		__PRI64_PREFIX "d"
# define SCNdLEAST8	"hhd"
# define SCNdLEAST16	"hd"
# define SCNdLEAST32	"d"
# define SCNdLEAST64	__PRI64_PREFIX "d"
# define SCNdFAST8	"hhd"
# define SCNdFAST16	__PRIPTR_PREFIX "d"
# define SCNdFAST32	__PRIPTR_PREFIX "d"
# define SCNdFAST64	__PRI64_PREFIX "d"
/* 有符号十进制格式  */
# define SCNi8		"hhi"
# define SCNi16		"hi"
# define SCNi32		"i"
# define SCNi64		__PRI64_PREFIX "i"
# define SCNiLEAST8	"hhi"
# define SCNiLEAST16	"hi"
# define SCNiLEAST32	"i"
# define SCNiLEAST64	__PRI64_PREFIX "i"
# define SCNiFAST8	"hhi"
# define SCNiFAST16	__PRIPTR_PREFIX "i"
# define SCNiFAST32	__PRIPTR_PREFIX "i"
# define SCNiFAST64	__PRI64_PREFIX "i"
/* 无符号十进制格式  */
# define SCNu8		"hhu"
# define SCNu16		"hu"
# define SCNu32		"u"
# define SCNu64		__PRI64_PREFIX "u"
# define SCNuLEAST8	"hhu"
# define SCNuLEAST16	"hu"
# define SCNuLEAST32	"u"
# define SCNuLEAST64	__PRI64_PREFIX "u"
# define SCNuFAST8	"hhu"
# define SCNuFAST16	__PRIPTR_PREFIX "u"
# define SCNuFAST32	__PRIPTR_PREFIX "u"
# define SCNuFAST64	__PRI64_PREFIX "u"
/* 八进制格式  */
# define SCNo8		"hho"
# define SCNo16		"ho"
# define SCNo32		"o"
# define SCNo64		__PRI64_PREFIX "o"
# define SCNoLEAST8	"hho"
# define SCNoLEAST16	"ho"
# define SCNoLEAST32	"o"
# define SCNoLEAST64	__PRI64_PREFIX "o"
# define SCNoFAST8	"hho"
# define SCNoFAST16	__PRIPTR_PREFIX "o"
# define SCNoFAST32	__PRIPTR_PREFIX "o"
# define SCNoFAST64	__PRI64_PREFIX "o"
/* 十六进制格式  */
# define SCNx8		"hhx"
# define SCNx16		"hx"
# define SCNx32		"x"
# define SCNx64		__PRI64_PREFIX "x"
# define SCNxLEAST8	"hhx"
# define SCNxLEAST16	"hx"
# define SCNxLEAST32	"x"
# define SCNxLEAST64	__PRI64_PREFIX "x"
# define SCNxFAST8	"hhx"
# define SCNxFAST16	__PRIPTR_PREFIX "x"
# define SCNxFAST32	__PRIPTR_PREFIX "x"
# define SCNxFAST64	__PRI64_PREFIX "x"

/* 输入intmax_t和uintmax_t的格式宏  */
# define SCNdMAX	__PRI64_PREFIX "d"
# define SCNiMAX	__PRI64_PREFIX "i"
# define SCNoMAX	__PRI64_PREFIX "o"
# define SCNuMAX	__PRI64_PREFIX "u"
# define SCNxMAX	__PRI64_PREFIX "x"
/* 输入intptr_t和uintptr_t的格式宏  */
# define SCNdPTR	__PRIPTR_PREFIX "d"
# define SCNiPTR	__PRIPTR_PREFIX "i"
# define SCNoPTR	__PRIPTR_PREFIX "o"
# define SCNuPTR	__PRIPTR_PREFIX "u"
# define SCNxPTR	__PRIPTR_PREFIX "x"
#endif	/* C++ && format macros */

__BEGIN_DECLS
#if __WORDSIZE == 64
/* 64位平台 */
/* 我们要使用ldiv_t来定义uintmax_t  */
typedef struct
  {
    long int quot;		/* 商  */
    long int rem;		/* 余数  */
  } imaxdiv_t;
#else   /*  32位平台 */
/* 我们要使用lldiv_t来定义uintmax_t  */
typedef struct
  {
    long long int quot;		/* 商  */
    long long int rem;		/* 余数  */
  } imaxdiv_t;
#endif
/* 计算N的绝对值  */
extern intmax_t imaxabs (intmax_t __n) __THROW __attribute__ ((__const__));
/* 返回NUMER除以DENOM的商和余数，放在imaxdiv_t结构中 */
extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
      __THROW __attribute__ ((__const__));
/* 与strtol类似，但转换成intmax_t  */
extern intmax_t strtoimax (__const char *__restrict __nptr,
			   char **__restrict __endptr, int __base) __THROW;
/* 与strtoul类似，但转换成uintmax_t  */
extern uintmax_t strtoumax (__const char *__restrict __nptr,
			    char ** __restrict __endptr, int __base) __THROW;
/* 与wcstol类似，但转换成intmax_t  */
extern intmax_t wcstoimax (__const __gwchar_t *__restrict __nptr,
			   __gwchar_t **__restrict __endptr, int __base)
     __THROW;
/* 与wcstoul类似，但转换成uintmax_t  */
extern uintmax_t wcstoumax (__const __gwchar_t *__restrict __nptr,
			    __gwchar_t ** __restrict __endptr, int __base)
     __THROW;
     
/* 下面是GNU的扩展：是上面4个标准转换函数的外部内联版本，有64位平台和32位平台之分 */
__END_DECLS
#endif /* inttypes.h */


stdint.h和inttypes.h参考

http://blog.csdn.net/zhoudaxia/article/details/4704766


fresh七天
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c编程可移植性考虑
b0207191的博客
03-18 2530
概述 为了缩短开发过程、降低开发成本，我们提倡软件复用。软件复用中常见的一个场景就是在不同产品或平台上使用同一套代码。这里就引入一个软件可移植性的概念。广义上来说，软件的可移植性是指软件从某一环境转移到另一环境下的难易程度。这里的环境可能是不同的硬件、软件…… 在本文中，可移植性特指从C语言角度而言，具体是指同一功能的C语言程序代码从某一平台(设备)移植到其他平台(设备)...
对于C语言可移植性的思考
weixin_33831196的博客
11-08 345
我相信学过C语言的同学，都会在书中看到C语言特点一定有：可移植性。但是什么是可移植？如何才能可移植？C语言是如何做到可移植的？对于初学者，可移植可能是一个经常遇到却很神秘的词。我想通过这篇文章来表达我对于可移植性的一些想法。 首先，在这里铺垫一下。学过Win32程序设计的人肯定都听说过API（Application Program Interface）。我就先说说A...
关于C语言的 可移植的数据类型
smallerxuan的博客
09-27 1916
关于C语言的 可移植的数据类型 对于数据类型，我们都知道它是什么，可以说是在熟悉不过的东西了。但是我们真的有关注过它么？被很多人忽视，或许是因为它太过基础了的原因。 拿C语言来说，要知道，在C语言的标准中，它并没有强制要求每种数据类型的具体长度，它实际上严格要求的是每种数据类型的最少长度，也就是说，不同的系统下，不同的编译器下，你定义的数据的实际长度可能是互不相同的。有没有发现什么？是
c语言的可移植性
qq_40715157的博客
05-12 2270
可移植类型：stdint.h和inttypes.h C 语言提供了许多有用的整数类型。但是，某些类型名在不同系统中的 功能不一样。C99 新增了两个头文件stdint.h和inttypes.h，以确保C语言的类 型在各系统中的功能相同。 C语言为现有类型创建了更多类型名。这些新的类型名定义在stdint.h头 文件中。例如，int32_t表示32位的有符号整数类型。在使用32位int的系统 中，头文件会把int32_t作为int的别名。不同的系统也可以定义相同的类型 名。例如，int为16位、long为32
C 程序的可移植性
02-27 1443
不是说 C 语言是一门跨平台的语言吗？不尽然，不同的平台对C语言做了不同程度的支持和拓展，所谓的拓展即是在原有的C标准的基础上，又设计和实现了高层的api。 如果只在 windows 平台下开发，或者只在 linux 平台下开发，也即只在单一平台下开发，是不会遇到程序移植性的问题的。本文以windows的观点，认识一些windows为 C 标准库做的拓展，也即如下的函数（api）不具有可移植性，也即
C语言的数据类型(1、2、3)[参照].pdf
10-11
总的来说，理解C语言的数据类型及其修饰符是编写有效、高效和可移植代码的关键。熟悉不同类型之间的转换规则，以及如何使用常量和变量，将有助于编写出符合规范且功能丰富的软件。在实际编程中，还需要关注类型安全...
你必须知道的495个C语言问题
05-14
这样是合法的和可移植的吗？ 2.8　我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明不能这样做？ 2.9　为什么不能用内建的==和!=操作符比较结构？ 2.10结构传递和返回是如何实现的？ 2.11　...
C语言数据结构——教程
05-21
C语言是计算机科学领域中的基础编程语言，以其高效、灵活和可移植性而闻名。在深入学习C语言的过程中，数据结构是不可或缺的一部分，它是理解算法和程序设计的关键。本教程将围绕C语言的数据结构展开，帮助读者掌握...
基于C语言实现学生考勤系统
最新发布
05-22
C语言具有高效、灵活和可移植性等特点，它的语法简洁明了，适合编写底层程序。在实现学生考勤系统时，我们需要掌握C语言的基本数据类型（如int、char、float等）、控制结构（如if-else、for、while循环）、函数定义...
什么是C语言的可移植？
03-21 1453
什么是可移植?如何才能可移植?C语言是如何做到可移植的?对于初学者，可移植可能是一个经常遇到却很神秘的词。今天，我想通过这篇文章来表达对于可移植性的一些想法。首先，在这里铺垫一下。学过Win32程序设计的人肯定都听说过API(Application Program Interface)。我就先说说API，高手绕过。API对于程序员来说就是系统提供的接口，任何涉及系统调用都要通过API来完成。对于不
C/C++ Windows移植到LINUX 的数据类型转换总结
08-01
c/c++ Windows移植到LINUX 的数据类型转换总结，都在WinToLinux.h文件中，需要时直接引入此头文件即可，很实用。
C 可移植数据类型 inttypes.h
寻梦小栈
12-23 1526
1. int16_t  确切长度类型：  16位有符号整数类型 某个系统可能不支持一些选择，比如，不能保证某个系统上存在一种int8_t类型 2. int_least8_t  最小长度类型：   可以容纳8位有符号数的哪些类型中长度最小的一个的别名。int_least8_t 的实现可能是16位整数。 3. int_fast8_t  最快最小长度类型 更关心速度，而非空
【C语言】C 语言我们称之为可移植性强，并不能跨平台，为什么呢？
m0_46566336的博客
09-16 3243
C 标准除了文件操作之外，是没有涉及到操作系统硬件资源的接口的，比如进程调度，网络通信等 ，这些接口均为每一个操作系统独有的，windows与 Linux 这些接口有差异，一旦你的 C 程序中使用了这些接口，代码放到另外一个平台就无法编译通过了
C语言 对可移植性的思考
本末实验室
09-19 2417
转载于：https://blog.csdn.net/chengxuyuan997/article/details/81126944     首先，在这里铺垫一下。学过Win32程序设计的人肯定都听说过API（Application Program Interface）。我就先说说API，高手绕过。API对于程序员来说就是系统提供的接口，任何涉及系统调用都要通过API来完成。对于不同的操作系统...
数据类型，可移植性的习题---c和指针
zx824
10-19 1748
3.13-3 题目： 假定你正编写一个程序，它必须运行于两台机器上。这两台机器的缺省整型长度并不相同，一个是16位，另一个是32位。而这两台机器的长整型长度分别是32位和64位。程序所使用的有些变量的值并不太大，足以保存于任何一台机器的缺省整型变量中，但有些变量的值却交大，必须是32为的整型变量才能容纳他。一种可行的解决方案是用长整型表示所有的值，但在16位机器上，也存在时间和空间的浪
如何理解编程语言的可移植性
鸿雁雀
11-13 6510
编程语言的可移植性意味着，用一种编程语言在一个系统上编写的程序经过很少改动或者不经修改就可以在其他系统平台上运行。     要想了解可移植性必须要知道：1.什么是程序？2.什么是系统平台？ 什么是程序    首先，我们得知道程序的本质是什么？程序的本质就是一连串能被CPU识别并执行的有0、1代码组成的指令即目标代码（0、1组成的代码）。不同类型的CPU指令集是不同的，相同的一段0、1代码in
C语言|《C Primer Plus》|可移植类型
weixin_43988792的博客
06-26 288
自学记录用；
C连载11-可移植类型、double、float
weixin_44630050的博客
06-30 440
一、可移植类型举例 1.系统不支持“精确宽度整数类型”怎么办？ 最小宽度类型：一些类型名保证所表示的类型一定是至少有指定宽度的最小整数类型。 使用上述定义的类型，例如：int_least8_t是可以容纳8位有符号整数值类型中的宽度最小的类型的一个别名，如果某系统的最小整数类型是16位，可能不会定义int8_t类型。尽管如此，该系统可能然会使用int_least8_t类型，但是可能把该类型实现为16位整数类型。 2.打印类型的转换有使用%d也有%ld的，该怎么办？ C语言提供了一些字符串宏来显示可移
数据结构与算法徐凤生习题答案1.doc
11-29
数据结构与算法徐凤生习题答案1.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值