自学教程：C++ COMPILE_TIME_ASSERT函数代码示例

/* * Initializes a MPI. * * A temporary MPI is allocated and if a bigInt is supplied the MPI is * initialized with the value of the bigInt. */static void get_mpi(mbedtls_mpi *mpi, const TEE_BigInt *bigInt){	/*	 * The way the GP spec is defining the bignums it's	 * difficult/tricky to do it using 64-bit arithmetics given that	 * we'd need 64-bit alignment of the data as well.	 */	COMPILE_TIME_ASSERT(sizeof(mbedtls_mpi_uint) == sizeof(uint32_t));	/*	 * The struct bigint_hdr is the overhead added to the bigint and	 * is required to take exactly 2 uint32_t.	 */	COMPILE_TIME_ASSERT(sizeof(struct bigint_hdr) ==			    sizeof(uint32_t) * BIGINT_HDR_SIZE_IN_U32);	mbedtls_mpi_init_mempool(mpi);	if (bigInt) {		const struct bigint_hdr *hdr = (struct bigint_hdr *)bigInt;		const mbedtls_mpi_uint *p = (const mbedtls_mpi_uint *)(hdr + 1);		size_t n = hdr->nblimbs;		/* Trim of eventual insignificant zeroes */		while (n && !p[n - 1])			n--;		MPI_CHECK(mbedtls_mpi_grow(mpi, n));		mpi->s = hdr->sign;		memcpy(mpi->p, p, n * sizeof(mbedtls_mpi_uint));	}}

 typename xtl::TypeTraits<T>::LengthType Sqrt(const T& a) {     typedef typename xtl::TypeTraits<T>::LengthType LengthType;     COMPILE_TIME_ASSERT(xtl::TypeTraits<T>::IsArithmetic);     COMPILE_TIME_ASSERT(xtl::TypeTraits<LengthType>::IsReal);     return sqrt(xtl::RealCast<LengthType>(a)); }

void CSocketAddress::ApplyStunXorMap(const StunTransactionId& transid){    const size_t iplen = (_address.addr.sa_family == AF_INET) ? STUN_IPV4_LENGTH : STUN_IPV6_LENGTH;    uint8_t* pPort;    uint8_t* pIP;    if (_address.addr.sa_family == AF_INET)    {        COMPILE_TIME_ASSERT(sizeof(_address.addr4.sin_addr) == STUN_IPV4_LENGTH); // 4        COMPILE_TIME_ASSERT(sizeof(_address.addr4.sin_port) == 2);        pPort = (uint8_t*)&(_address.addr4.sin_port);        pIP = (uint8_t*)&(_address.addr4.sin_addr);    }    else    {        COMPILE_TIME_ASSERT(sizeof(_address.addr6.sin6_addr) == STUN_IPV6_LENGTH); // 16        COMPILE_TIME_ASSERT(sizeof(_address.addr6.sin6_port) == 2);        pPort = (uint8_t*)&(_address.addr6.sin6_port);        pIP = (uint8_t*)&(_address.addr6.sin6_addr);    }        pPort[0] = pPort[0] ^ transid.id[0];    pPort[1] = pPort[1] ^ transid.id[1];        for (size_t i = 0; i < iplen; i++)    {        pIP[i] = pIP[i] ^ transid.id[i];    }}

PackUnix::PackUnix(InputFile *f) :    super(f), exetype(0), blocksize(0), overlay_offset(0), lsize(0){    COMPILE_TIME_ASSERT(sizeof(Elf32_Ehdr) == 52);    COMPILE_TIME_ASSERT(sizeof(Elf32_Phdr) == 32);    COMPILE_TIME_ASSERT(sizeof(b_info) == 12);    COMPILE_TIME_ASSERT(sizeof(l_info) == 12);    COMPILE_TIME_ASSERT(sizeof(p_info) == 12);}

/* * Called once (from main) to initialize STM infrastructure. */_CALLCONV voidstm_init(void){#if CM == CM_MODULAR    char *s;#endif /* CM == CM_MODULAR */#ifdef SIGNAL_HANDLER    struct sigaction act;#endif /* SIGNAL_HANDLER */    PRINT_DEBUG("==> stm_init()/n");    if (_tinystm.initialized)        return;    PRINT_DEBUG("/tsizeof(word)=%d/n", (int)sizeof(stm_word_t));    PRINT_DEBUG("/tVERSION_MAX=0x%lx/n", (unsigned long)VERSION_MAX);    COMPILE_TIME_ASSERT(sizeof(stm_word_t) == sizeof(void *));    COMPILE_TIME_ASSERT(sizeof(stm_word_t) == sizeof(atomic_t));#ifdef EPOCH_GC    gc_init(stm_get_clock);#endif /* EPOCH_GC */#if CM == CM_MODULAR    s = getenv(VR_THRESHOLD);    if (s != NULL)        _tinystm.vr_threshold = (int)strtol(s, NULL, 10);    else        _tinystm.vr_threshold = VR_THRESHOLD_DEFAULT;    PRINT_DEBUG("/tVR_THRESHOLD=%d/n", _tinystm.vr_threshold);#endif /* CM == CM_MODULAR */    /* Set locks and clock but should be already to 0 */    memset((void *)_tinystm.locks, 0, LOCK_ARRAY_SIZE * sizeof(stm_word_t));    CLOCK = 0;    stm_quiesce_init();    tls_init();#ifdef SIGNAL_HANDLER    if (getenv(NO_SIGNAL_HANDLER) == NULL) {        /* Catch signals for non-faulting load */        act.sa_handler = signal_catcher;        act.sa_flags = 0;        sigemptyset(&act.sa_mask);        if (sigaction(SIGBUS, &act, NULL) < 0 || sigaction(SIGSEGV, &act, NULL) < 0) {            perror("sigaction");            exit(1);        }    }#endif /* SIGNAL_HANDLER */    _tinystm.initialized = 1;}

//-----------------------------------------------------------------------------// Purpose: Constructor//-----------------------------------------------------------------------------CObjectBuffStation::CObjectBuffStation(){	// Verify networking data.	COMPILE_TIME_ASSERT( BUFF_STATION_MAX_PLAYERS < ( 1 << BUFF_STATION_MAX_PLAYER_BITS ) );	COMPILE_TIME_ASSERT( BUFF_STATION_MAX_PLAYERS >= ( 1 << ( BUFF_STATION_MAX_PLAYER_BITS - 1 ) ) );	COMPILE_TIME_ASSERT( BUFF_STATION_MAX_OBJECTS < ( 1 << BUFF_STATION_MAX_OBJECT_BITS ) );	COMPILE_TIME_ASSERT( BUFF_STATION_MAX_OBJECTS >= ( 1 << ( BUFF_STATION_MAX_OBJECT_BITS - 1 ) ) );	// Uses the client-side animation system.	UseClientSideAnimation();}

static void sanity_checks(){  COMPILE_TIME_ASSERT(sizeof(convert_64_t) == 8);  COMPILE_TIME_ASSERT(sizeof(convert_32_t) == 4);  COMPILE_TIME_ASSERT(sizeof(stm_word_t) == 4 || sizeof(stm_word_t) == 8);  COMPILE_TIME_ASSERT(sizeof(char) == 1);  COMPILE_TIME_ASSERT(sizeof(short) == 2);  COMPILE_TIME_ASSERT(sizeof(int) == 4);  COMPILE_TIME_ASSERT(sizeof(long) == 4 || sizeof(long) == 8);  COMPILE_TIME_ASSERT(sizeof(float) == 4);  COMPILE_TIME_ASSERT(sizeof(double) == 8);}

XmlNodeRef CScoreIncEvent::GetXML(IGameStatistics* pGS){	XmlNodeRef node = pGS->CreateStatXMLNode();	node->setAttr("score", m_score);	COMPILE_TIME_ASSERT(EGRST_Num==ARRAY_COUNT(k_ScoreIncTypeStrs));	EGameRulesScoreType type=m_type;	const char *pStr = "Unknown";	if (m_type>=0 && m_type<ARRAY_COUNT(k_ScoreIncTypeStrs))	{		pStr = k_ScoreIncTypeStrs[m_type];	}	// skip code prefixes from enums to make them more human readable	if (strncmp(pStr,"EGRST_",6)==0)	{		pStr+=6;	}	node->setAttr("type", pStr);	return node;}

 typename xtl::TypeTraits<T>::AccumType Square(const T& a) {     COMPILE_TIME_ASSERT(xtl::TypeTraits<T>::IsArithmetic);     typedef typename xtl::TypeTraits<T>::AccumType AccumType;     AccumType b = xtl::RealCast<AccumType>(a);     return b * b; }

PackVmlinuzI386::PackVmlinuzI386(InputFile *f) :    super(f), physical_start(0x100000), page_offset(0), config_physical_align(0)    , filter_len(0){    bele = &N_BELE_RTP::le_policy;    COMPILE_TIME_ASSERT(sizeof(boot_sect_t) == 0x250);}

HRESULT CSocketAddress::GetLocalHost(uint16_t family, CSocketAddress* pAddr){        if (  ((family != AF_INET) && (family != AF_INET6)) ||           (pAddr == NULL))    {        ASSERT(false);        return E_FAIL;    }        if (family == AF_INET)    {        uint32_t ip = 0x7f000001; // 127.0.0.1 in host byte order        *pAddr = CSocketAddress(ip, 0);    }    else    {        sockaddr_in6 addr6 = {};        COMPILE_TIME_ASSERT(sizeof(addr6.sin6_addr) == 16);                // ::1        uint8_t ip6[16] = {};        ip6[15] = 1;        addr6.sin6_family = AF_INET6;        memcpy(&addr6.sin6_addr, ip6, 16);        *pAddr = CSocketAddress(addr6);    }        return S_OK;}

BOOL Identify(HANDLE hPhysical){	ATA_PASSTHROUGH_CMD Command = {0};	IDENTIFY_DEVICE_DATA* idd;	int i, r;	Command.AtaCmd = ATA_IDENTIFY_DEVICE;	// You'll get an error here if your compiler does not properly pack the IDENTIFY struct	COMPILE_TIME_ASSERT(sizeof(IDENTIFY_DEVICE_DATA) == 512);	idd = (IDENTIFY_DEVICE_DATA*)_mm_malloc(sizeof(IDENTIFY_DEVICE_DATA), 0x10);	if (idd == NULL)		return FALSE;	for (i=0; i<ARRAYSIZE(pt); i++) {		r = pt[i].fn(hPhysical, &Command, idd, sizeof(IDENTIFY_DEVICE_DATA), SPT_TIMEOUT_VALUE);		if (r == SPT_SUCCESS) {			uprintf("Success using %s/n", pt[i].type);			if (idd->CommandSetSupport.SmartCommands) {				DumpBufferHex(idd, sizeof(IDENTIFY_DEVICE_DATA));				uprintf("SMART support detected!/n");			} else {				uprintf("No SMART support/n");			}			break;		}		uprintf("No joy with: %s (%s)/n", pt[i].type, SptStrerr(r));	}	if (i >= ARRAYSIZE(pt))		uprintf("NO ATA FOR YOU!/n");	_mm_free(idd);	return TRUE;}

static void *raw_malloc(size_t hdr_size, size_t ftr_size, size_t pl_size){	void *ptr = NULL;	size_t s = hdr_size + ftr_size + pl_size;	/*	 * Make sure that malloc has correct alignment of returned buffers.	 * The assumption is that uintptr_t will be as wide as the largest	 * required alignment of any type.	 */	COMPILE_TIME_ASSERT(SizeQuant >= sizeof(uintptr_t));	raw_malloc_validate_pools();	/* Check wrapping */	if (s < pl_size)		goto out;	/* BGET doesn't like 0 sized allocations */	if (!s)		s++;	ptr = bget(s);out:	raw_malloc_return_hook(ptr, pl_size);	return ptr;}

struct grub_net_buff *grub_netbuff_alloc (grub_size_t len){  struct grub_net_buff *nb;  void *data;  COMPILE_TIME_ASSERT (NETBUFF_ALIGN % sizeof (grub_properly_aligned_t) == 0);  if (len < NETBUFFMINLEN)    len = NETBUFFMINLEN;  len = ALIGN_UP (len, NETBUFF_ALIGN);#ifdef GRUB_MACHINE_EMU  data = grub_malloc (len + sizeof (*nb));#else  data = grub_memalign (NETBUFF_ALIGN, len + sizeof (*nb));#endif  if (!data)    return NULL;  nb = (struct grub_net_buff *) ((grub_properly_aligned_t *) data				 + len / sizeof (grub_properly_aligned_t));  nb->head = nb->data = nb->tail = data;  nb->end = (grub_uint8_t *) nb;  return nb;}

uint32_t_cairo_xcb_connection_shm_attach (cairo_xcb_connection_t *connection,                                  uint32_t id,                                  cairo_bool_t readonly){    struct {        uint8_t req;        uint8_t shm_req;        uint16_t length;        uint32_t segment;        uint32_t id;        uint8_t readonly;        uint8_t pad1;        uint16_t pad2;    } req;    struct iovec vec[1];    COMPILE_TIME_ASSERT (sizeof (req) == 16);    req.req = connection->shm->major_opcode;    req.shm_req = 1;    req.length = sizeof (req) >> 2;    req.segment = _cairo_xcb_connection_get_xid (connection);    req.id = id;    req.readonly = readonly;    vec[0].iov_base = &req;    vec[0].iov_len = sizeof (req);    _cairo_xcb_connection_write (connection, vec, 1);    return req.segment;}

//-----------------------------------------------------------------------------// Gets at the nth item in the list//-----------------------------------------------------------------------------TrailPoint_t *CSpriteTrail::GetTrailPoint( int n ){	Assert( n < MAX_SPRITE_TRAIL_POINTS );	COMPILE_TIME_ASSERT( (MAX_SPRITE_TRAIL_POINTS & (MAX_SPRITE_TRAIL_POINTS-1)) == 0 );	int nIndex = (n + m_nFirstStep) & MAX_SPRITE_TRAIL_MASK; 	return &m_vecSteps[nIndex];}

void_cairo_xcb_connection_shm_detach (cairo_xcb_connection_t *connection,                                  uint32_t segment){    struct {        uint8_t req;        uint8_t shm_req;        uint16_t length;        uint32_t segment;    } req;    struct iovec vec[1];    COMPILE_TIME_ASSERT (sizeof (req) == 8);    req.req = connection->shm->major_opcode;    req.shm_req = 2;    req.length = sizeof (req) >> 2;    req.segment = segment;    vec[0].iov_base = &req;    vec[0].iov_len = sizeof (req);    _cairo_xcb_connection_write (connection, vec, 1);    _cairo_xcb_connection_put_xid (connection, segment);}

	virtual void GetConfiguration( SFlowNodeConfig& config )	{		COMPILE_TIME_ASSERT( PORT_NONE + 1 == 0 );  // or else the automatic boundary checks when incrememting the port number would not work		static const SInputPortConfig in_config[] = {			InputPortConfig_AnyType("In", _HELP("Input")),			InputPortConfig<bool> ( "Closed", false, _HELP("If true blocks all signals.")),			InputPortConfig_Void  ( "Open", _HELP("Sets [Closed] to false.")),			InputPortConfig_Void  ( "Close", _HELP("Sets [Closed] to true.")),			InputPortConfig_Void	("Reset", _HELP("Forces next output to be Port1 again")),			InputPortConfig<bool> ( "Reverse", false, _HELP("If true, the order of output activation is reversed.")),			{0}		};		static const SOutputPortConfig out_config[] = {			OutputPortConfig_AnyType("Out1", _HELP("Output1")),			OutputPortConfig_AnyType("Out2", _HELP("Output2")),			OutputPortConfig_AnyType("Out3", _HELP("Output3")),			OutputPortConfig_AnyType("Out4", _HELP("Output4")),			OutputPortConfig_AnyType("Out5", _HELP("Output5")),			OutputPortConfig_AnyType("Out6", _HELP("Output6")),			OutputPortConfig_AnyType("Out7", _HELP("Output7")),			OutputPortConfig_AnyType("Out8", _HELP("Output8")),			OutputPortConfig_AnyType("Out9", _HELP("Output9")),			OutputPortConfig_AnyType("Out10", _HELP("Output10")),			{0}		};		config.sDescription = _HELP("On each [In] trigger, triggers one of the connected outputs in sequential order.");		config.pInputPorts = in_config;		config.pOutputPorts = out_config;		config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;		config.SetCategory(EFLN_APPROVED);	}

const cascade_t &GetCascadeInfo( int index ){	Assert( index >= 0 && index < iNumCascades );	COMPILE_TIME_ASSERT( iNumCascades == SHADOW_NUM_CASCADES );	return g_CascadeInfo[ index ];}

void tee_svc_handler(struct thread_svc_regs *regs){	size_t scn;	size_t max_args;	syscall_t scf;	COMPILE_TIME_ASSERT(ARRAY_SIZE(tee_svc_syscall_table) ==				(TEE_SCN_MAX + 1));	/* Restore IRQ which are disabled on exception entry */	thread_restore_irq();	thread_disable_concurrency();	get_scn_max_args(regs, &scn, &max_args);#if (TRACE_LEVEL == TRACE_FLOW) && defined(CFG_TEE_CORE_TA_TRACE)	tee_svc_trace_syscall(scn);#endif	if (max_args > TEE_SVC_MAX_ARGS) {		DMSG("Too many arguments for SCN %zu (%zu)", scn, max_args);		set_svc_retval(regs, TEE_ERROR_GENERIC);		return;	}	if (scn > TEE_SCN_MAX)		scf = syscall_nocall;	else		scf = tee_svc_syscall_table[scn];	set_svc_retval(regs, tee_svc_do_call(regs, scf));	thread_enable_concurrency();}

/* * Initialize PL061 GPIO controller */void pl061_init(struct pl061_data *pd){	COMPILE_TIME_ASSERT(PLAT_PL061_MAX_GPIOS > 0);	assert(pd);	pd->chip.ops = &pl061_ops;}

inline Registers_ppc::Registers_ppc(const void* registers) {	COMPILE_TIME_ASSERT( sizeof(Registers_ppc) < sizeof(unw_context_t) );	fRegisters = *((ppc_thread_state_t*)registers); 	fFloatRegisters = *((ppc_float_state_t*)((char*)registers+160));	memcpy(fVectorRegisters, ((char*)registers+424), sizeof(fVectorRegisters));}

void CSoundParametersInternal::AddToTail( SoundFile **pDest, uint16 *pDestCount, const SoundFile &source ){	(*pDestCount)++;	if ( *pDestCount == 1 )	{		// NOTE: when there's only one soundfile in the list, we store it		// packed into the pointer itself, the four bytes for the pointer is just used to store the sound file!		COMPILE_TIME_ASSERT( sizeof(SoundFile) <= sizeof(SoundFile *) );		*((SoundFile *)(pDest)) = source;	}	else	{		SoundFile temp;		if ( *pDestCount == 2 )		{			// Copying from a list of one soundfile. Save off the struct			// packed into the pointer field.			temp = *((SoundFile *)(pDest));			*pDest = NULL;		}		*pDest = (SoundFile *)realloc( *pDest, (*pDestCount) * sizeof(SoundFile) );		(*pDest)[ *pDestCount - 1 ] = source;		if ( *pDestCount == 2 )		{			(*pDest)[0] = temp;		}	}}

void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, int value) {        COMPILE_TIME_ASSERT(sizeof(int) == 4);    o.sign = false;    o.ebits = ebits;    o.sbits = sbits;        TRACE("mpf_dbg", tout << "set: value = " << value << std::endl;);

static inline grub_uint32_tgrub_nilfs2_palloc_log_groups_per_desc_block (struct grub_nilfs2_data *data){  return LOG2_BLOCK_SIZE (data) - LOG_SIZE_GROUP_DESC;  COMPILE_TIME_ASSERT (sizeof (struct grub_nilfs2_palloc_group_desc)		       == (1 << LOG_SIZE_GROUP_DESC));}

const char *GetWeaponProficiencyName( WeaponProficiency_t proficiency ){	COMPILE_TIME_ASSERT( ARRAYSIZE(g_ProficiencyNames) == WEAPON_PROFICIENCY_PERFECT + 1 ); // Hey, update that there table!	if ( proficiency < 0 || proficiency > WEAPON_PROFICIENCY_PERFECT )		return "<<Invalid>>";	return g_ProficiencyNames[proficiency];}

int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,                                   upx_bytep dst, unsigned* dst_len,                                   upx_callback_p cb_parm,                                   int method, int level,                             const upx_compress_config_t *cconf_parm,                                   upx_compress_result_t *cresult ){    int r;    assert(level > 0); assert(cresult != NULL);    COMPILE_TIME_ASSERT(sizeof(ucl_compress_config_t) == sizeof(REAL_ucl_compress_config_t))    ucl_progress_callback_t cb;    cb.callback = 0;    cb.user = NULL;    if (cb_parm && cb_parm->nprogress) {        cb.callback = wrap_nprogress_ucl;        cb.user = cb_parm;    }    ucl_compress_config_t cconf; cconf.reset();    if (cconf_parm)        memcpy(&cconf, &cconf_parm->conf_ucl, sizeof(cconf)); // cconf = cconf_parm->conf_ucl; // struct copy    ucl_uint *res = cresult->result_ucl.result;    // assume no info available - fill in worst case results    //res[0] = 1;                 // min_offset_found - NOT USED    res[1] = src_len - 1;       // max_offset_found    //res[2] = 2;                 // min_match_found - NOT USED    res[3] = src_len - 1;       // max_match_found    //res[4] = 1;                 // min_run_found - NOT USED    res[5] = src_len;           // max_run_found    res[6] = 1;                 // first_offset_found    //res[7] = 999999;            // same_match_offsets_found - NOT USED    // prepare bit-buffer settings    cconf.bb_endian = 0;    cconf.bb_size = 0;    if (method >= M_NRV2B_LE32 && method <= M_NRV2E_LE16)    {        static const unsigned char sizes[3] = {32, 8, 16};        cconf.bb_size = sizes[(method - M_NRV2B_LE32) % 3];    }    else {        throwInternalError("unknown compression method");        return UPX_E_ERROR;    }    // optimize compression parms    if (level <= 3 && cconf.max_offset == UCL_UINT_MAX)        cconf.max_offset = 8*1024-1;    else if (level == 4 && cconf.max_offset == UCL_UINT_MAX)        cconf.max_offset = 32*1024-1;    if M_IS_NRV2B(method)        r = ucl_nrv2b_99_compress(src, src_len, dst, dst_len,                                  &cb, level, &cconf, res);    else if M_IS_NRV2D(method)

static uint32_t desc_to_mattr(uint64_t desc){	uint32_t a;	if (!(desc & 1)) {		if (desc & HIDDEN_DESC)			return TEE_MATTR_HIDDEN_BLOCK;		if (desc & PHYSPAGE_DESC)			return TEE_MATTR_PHYS_BLOCK;		return 0;	}	a = TEE_MATTR_VALID_BLOCK;	if (desc & LOWER_ATTRS(ACCESS_FLAG))		a |= TEE_MATTR_PRX | TEE_MATTR_URX;	if (!(desc & LOWER_ATTRS(AP_RO)))		a |= TEE_MATTR_PW | TEE_MATTR_UW;	if (!(desc & LOWER_ATTRS(AP_UNPRIV)))		a &= ~TEE_MATTR_URWX;	if (desc & UPPER_ATTRS(XN))		a &= ~(TEE_MATTR_PX | TEE_MATTR_UX);	if (desc & UPPER_ATTRS(PXN))		a &= ~TEE_MATTR_PX;	COMPILE_TIME_ASSERT(ATTR_DEVICE_INDEX == TEE_MATTR_CACHE_NONCACHE);	COMPILE_TIME_ASSERT(ATTR_IWBWA_OWBWA_NTR_INDEX ==			    TEE_MATTR_CACHE_CACHED);	a |= ((desc & LOWER_ATTRS(ATTR_INDEX_MASK)) >> LOWER_ATTRS_SHIFT) <<	     TEE_MATTR_CACHE_SHIFT;	if (!(desc & LOWER_ATTRS(NON_GLOBAL)))		a |= TEE_MATTR_GLOBAL;	if (!(desc & LOWER_ATTRS(NS)))		a |= TEE_MATTR_SECURE;	return a;}

int main(int argc, char** argv, char** envp) {	COMPILE_TIME_ASSERT(1==1);	PR_STATIC_ASSERT(1==1);	// this is a built in gcc static assertion, no flags needed	_Static_assert(1==1, "fail message");	ct_assert(1==1);	STATIC_ASSERT(1==1, fail);	// CTC(1==1);	return EXIT_SUCCESS;}