C++ 项目成长 ——自定义数据类型，定义各种类型别名， typedef的部分用法实例

概要

     书接上回，项目开始定义了一些系统的平台参数，具体可参见下面的文章：C++ 项目成长 —— 定义跨平台的参数宏的文件记录。

     同时，在上次我们尝试去定义了一些编译选项自定义的宏，来控制不同的编译选项的时候，能够做一些区分，具体可以参考下面的文章：C++ 项目成长 —— 自定义编译参数宏，区分编译选项

     那么今天，我就想要来说道说道，如何来定义自己的类型，如果你希望在自己的项目里面，能够在编译的时候，或者提供SDK的时候，能够对外暴露的仅仅是自己定义的类型，或者改成一个别名来隐藏一些你希望隐藏的代码时，那么我们就需要用到今天进行的参数类型的定义，看看是怎么做的吧。

TZOpenTools

zsofts_types.h

///
// Copyright (c)2020, Tom Zhao personal. ("TZOpenTools")
// This software is a personal tools project by Tom Zhao.
// Description:
///


#ifndef __TZ_SOFTS_TYPES_H_INCLUDE__
#define __TZ_SOFTS_TYPES_H_INCLUDE__

#include "zsofts_platform.h"
#include "zsofts_compiler_specific.h"

// include limits and some types definitions.
#include <limits.h>
#include <stddef.h>
#include <tchar.h>
#include <stdint.h>

#if         USHRT_MAX == 0xFFFFU
#define TZ_SIZEOF_SHORT 2
#else
    #error "Unsupported short size!\n"
#endif // #if         USHRT_MAX == 0xFFFFU

#ifdef __LP64__
#define TZ_SIZEOF_LONG 8
#else
#define TZ_SIZEOF_LONG 4
#endif // __LP64__

#if             TZ_ARCHITECURE_BIT == TZ_ARCHITECTURE_BIT64
#define TZ_SIZEOF_POINTER 8
#elif           TZ_ARCHITECURE_BIT == TZ_ARCHITECTURE_BIT32
#define TZ_SIZOF_POINTER 4
#else
    #error "Unsupported architecture bit!\n"
#endif // TZ_ARCHITECURE_BIT == TZ_ARCHITECTURE_BIT32

#if     (defined(WIN32) || defined(WIN64))
#define TZCHAR_IS_INT16LE 1
#else
#define TZCHAR_IS_INT16LE 0
#endif

typedef void* RTContext;    // Running time context, refers to fiber or coroutine.
typedef int8_t						TZINT8;
typedef uint8_t                     TZUINT8;
typedef int16_t                     TZINT16;
typedef uint16_t                   TZUINT16;

// long is not recommended when crossing platforms.
// But we define TZINT32 as long in Win32 for compatibility.
#if     TZ_SIZEOF_LONG == 8
    typedef int32_t                     TZINT32;
    typedef uint32_t                   TZUINT32;
#else
    typedef long                         TZINT32;
    typedef unsigned long         TZUINT32;
#endif

#ifdef TZ_WINDOWS
    typedef int64_t                     TZINT64;
    typedef uint64_t                   TZUINT64;
#else
    typedef __int64                     TZINT64;
    typedef unsigned __int64     TZUINT64;
#endif // TZ_WINDOWS

typedef float                         TZFLOAT32;
typedef double                     TZFLOAT64;

typedef char                           TZCHAR;
typedef wchar_t                      TZWCHAR;
typedef unsigned char           TZUCHAR;

#if TZ_BUILD_CHARACTERS == TZ_CHARACTERS_MBCS
typedef TZCHAR							TZTCHAR;
#define TZ__T(X)							X
#elif TZ_BUILD_CHARACTERS == TZ_CHARACTERS_UNICODE
typedef TZWCHAR                      TZTCHAR;
#define TZ__T(X)							L  ## X
#else
typedef TZCHAR							TZTCHAR;
#define TZ__T(X)							X
#endif
#define TZ_T(X)                            TZ__T(X)

typedef TZCHAR*                     TZPSTR;
typedef const TZCHAR*           TZPCSTR;

typedef TZWCHAR*                 TZPWSTR;
typedef const TZWCHAR*       TZPCWSTR;
typedef TZUCHAR*                  TZPMBSTR;
typedef const TZUCHAR*        TZCMBSTR;

typedef void*                           TZPVOID;
typedef const void*                 TZPCVOID;

#ifndef TZ_X64
    typedef __w64 long                  TZLONGPTR;
    typedef __w64 unsigned long  TZULONGPTR;
    typedef __w64 int                     TZINTPTR;
    typedef __w64 unsigned int     TZUINGPTR;
#else // TZ_X64
    #ifndef TZ_WINDOWS
        typedef int64_t                         TZLONGPTR;
        typedef uint64_t                       TZULONGPTR;
        typedef int64_t                         TZ_INTPTR;
        typedef uint64_t                       TZUINTPTR;
    #else
        typedef __int64                         TZLONGPTR;
        typedef unsigned __int64         TZULONGPTR;
        typedef __int64                         TZ_INTPTR;
        typedef unsigned __int64         TZUINTPTR;
#endif // TZ_WINDOWS

#endif // TZ_X64

typedef TZULONGPTR             TZADDRESS;

typedef unsigned char             TZBYTE;

#ifndef __LP64__
typedef int                                TZBOOL;
#else
typedef bool                             TZBOOL;
#endif // __LP64__

typedef short                            TZSHORT;
typedef int                                TZINT;
typedef long                             TZLONG;
typedef long long                     TZLLONG;
typedef unsigned short            TZUSHORT;
typedef unsigned int                TZUINT;
typedef unsigned long             TZULONG;
typedef unsigned long long     TZULLONG;

typedef TZUINT16                    TZWORD;
typedef TZUINT32                    TZDWORD;
typedef TZUINT64                    TZQWORD;

typedef float                             TZFLOAT;
typedef double                         TZDOUBLE;
typedef long double                 TZLDOUBLE;
typedef size_t                            TZSIZET;
typedef TZLONGPTR                 WindowId;

// Path
#define TZ_MAX_DRIVE 3
#define TZ_MAX_PATH 260
#define TZ_MAX_FNAME 256
#define TZ_MAX_DIR 256
#define TZ_MAX_EXT 256
#define TZ_BIG_MAX_FNAME 1024
#define TZ_MAX_FULL_PATH 4096

#define TZMIN(a,  b)				(((a) < (b)) ? (a) : (b))
#define TZMAX(a, b)				(((a) > (b)) ? (a) : (b))

#define TZBYTE_BIT CHAR_BIT
#define TZWORD_BIT (CHAR_BIT*sizeof(TZWORD))
#define TZDWORD_BIT (CHAR_BIT * sizeof(TZDWORD))
#define TZQWORD_BIT (CHAR_BIT * sizeof(TZQWORD))

#define TZBYTE_MAX ((TZBYTE)(-1))
#define TZWORD_MAX ((TZWORD)(-1))
#define TZDWORD_MAX ((TZDWORD)(-1))
#define TZQWORD_MAX ((TZQWORD)(-1))

#define TZMAKEWORD(a, b)					((TZWORD)(((TZBYTE)(((TZWORD)(a)) & TZBYTE_MAX)) | ((TZWORD)((TZBYTE)(((TZWORD)(b)) & TZBYTE_MAX))) << TZBYTE_BIT))
#define TZLOBYTE(w)								((TZBYTE)(((TZWORD)(w)) & TZBYTE_MAX))
#define TZHIBYTE(w)								((TZBYTE)((((TZWORD)(w)) >> TZBYTE_BIT)& TZBYTE_MAX))

#define TZMAKEDWORD(a, b)				((TZDWORD)(((TZWORD)(((TZDWORD)(a)) & TZWORD_MAX)) | ((TZDWORD)((TZWORD)(((TZDWORD)(b)) & TZWORD_MAX))) << TZWORD_BIT))
#define TZLOWORD(dw)							((TZWORD)(((TZDWORD)(dw)) & TZWORD_MAX))
#define TZHIWORD(dw)							((TZWORD)((((TZDWORD)(dw)) >> TZWORD_BIT) & TZWORD_MAX))

#define TZMAKEQWORD(a, b)				((TZQWORD)(((TZWORD)(((TZQWORD)(a)) & TZDWORD_MAX)) | ((TZQWORD)((TZWORD)(((TZQWORD)(b)) & TZDWORD_MAX))) << TZDWORD_BIT))
#define TZLODWORD(qw)						((TZDWORD)(((TZQWORD)(qw)) & TZDWORD_MAX))
#define TZHIDWORD(qw)						((TZDWORD)((((TZQWORD)(qw)) >> TZDWORD_BIT) & TZDWORD_MAX))

#define TZGETBIT(f, b)							(((f) & (b)) ? true : false)
#define TZGETBITS(f, b)							((((f) & (b)) ^ (b)) ? false : true)
#define TZSETBIT(f, b, v)							((v) ? ((f) |= (b)) : ((f) &= ~(b)))
#define TZ_NUM_ARRAYE(x)					(sizeof(x) / sizeof(x[0]))

#ifndef NULL
    #ifdef __cplusplus
        #define  NULL 0
    #else
        #define NULL ((void *)0)
    #endif
#endif // __cplusplus

// Constant
#ifndef TRUE
    #define TRUE 1
#endif

#ifndef FALSE
    #define FALSE 0
#endif

#ifndef TZEOS
    #define TZEOS           TZ_T('\0')
#endif

#ifndef TZEOSA
    #define TZEOSA         '\0'
#endif

#ifndef TZEOSW
#define TZEOSW           L'\0'
#endif

#if defined(_IA64_) || (TZ_COMPILER == TZ_COMPILER_MSVC && (TZ_COMPILER_VER >= 1020) || (TZ_COMPILER == TZ_COMPILER_BORL) || (TZ_COMPILER_VER == __BCPLUSPLUS__))
    #define BUILTIN_INT64 __int64
    #define PERCENT18LONG "%18I64d\r\n"
#elif TZ_SIZEOF_POINTER == 8
    #define BUILTIN_INT64 long
    #define PERCENT18LONG "%18Id\r\n"
#elif defined(__MWERKS__) || defined(__GNUC__) || defined(sgi) || defined(_AIX) || defined(__sun) || defined(__hpux)
    #define BUILTIN_INT64 long long
    #define PERCENT18LONG "%18Ild\r\n"
#endif

#ifndef  BUILTIN_INT64
    #define PERCENT18LONG "%18d\r\n"
#endif

#endif

个人格言

    用心去感受你自己需要坚持的生活，未来慢慢会给你答案的。