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

size_t parse_size_t(const char* str, size_t def){	if ( !str || !*str )		return def;	char* endptr;	size_t ret = (size_t) strtoumax(str, &endptr, 10);	if ( *endptr )		return def;	return ret;}

static inline int ini_process_word(const char* curr_name, const char* value, const char* option_name, word* target, ini_value_list_type* value_names) {    if(strcasecmp(curr_name, option_name) == 0) {        if (strcasecmp(value, "default") != 0) {            int named_value = ini_get_named_value(value, value_names);            *target = (named_value == INI_NO_VALID_NAME) ? ((word) strtoumax(value, NULL, 0)) : ((word) named_value);        }        return 1; // finished; don't look for more possible options that curr_name can be    }    return 0; // not the right option; should check another option_name}

status_tIntegerValueFormatter::_ValidateUnsigned(const BString& input, type_code type,        ::Value*& _output, integer_format format, bool wantsValue) const{    const char* text = input.String();    int32 base = format == INTEGER_FORMAT_UNSIGNED ? 10 : 16;    char *parseEnd = NULL;    uintmax_t parsedValue = strtoumax(text, &parseEnd, base);    if (parseEnd - text < input.Length() && !isspace(*parseEnd))        return B_BAD_VALUE;    BVariant newValue;    switch (type) {    case B_UINT8_TYPE:    {        if (parsedValue > UINT8_MAX)            return B_BAD_VALUE;        newValue.SetTo((uint8)parsedValue);        break;    }    case B_UINT16_TYPE:    {        if (parsedValue > UINT16_MAX)            return B_BAD_VALUE;        newValue.SetTo((uint16)parsedValue);        break;    }    case B_UINT32_TYPE:    {        if (parsedValue > UINT32_MAX)            return B_BAD_VALUE;        newValue.SetTo((uint32)parsedValue);        break;    }    case B_UINT64_TYPE:    {        newValue.SetTo((uint64)parsedValue);        break;    }    default:        return B_BAD_VALUE;    }    if (wantsValue) {        _output = new(std::nothrow) IntegerValue(newValue);        if (_output == NULL)            return B_NO_MEMORY;    }    return B_OK;}

int main(){    {    int8_t  i1 = 0;    int16_t i2 = 0;    int32_t i3 = 0;    int64_t i4 = 0;    }    {    uint8_t  i1 = 0;    uint16_t i2 = 0;    uint32_t i3 = 0;    uint64_t i4 = 0;    }    {    int_least8_t  i1 = 0;    int_least16_t i2 = 0;    int_least32_t i3 = 0;    int_least64_t i4 = 0;    }    {    uint_least8_t  i1 = 0;    uint_least16_t i2 = 0;    uint_least32_t i3 = 0;    uint_least64_t i4 = 0;    }    {    int_fast8_t  i1 = 0;    int_fast16_t i2 = 0;    int_fast32_t i3 = 0;    int_fast64_t i4 = 0;    }    {    uint_fast8_t  i1 = 0;    uint_fast16_t i2 = 0;    uint_fast32_t i3 = 0;    uint_fast64_t i4 = 0;    }    {    intptr_t  i1 = 0;    uintptr_t i2 = 0;    intmax_t  i3 = 0;    uintmax_t i4 = 0;    }    {    imaxdiv_t  i1 = {0};    }    intmax_t i = 0;    static_assert((std::is_same<decltype(imaxabs(i)), intmax_t>::value), "");    static_assert((std::is_same<decltype(imaxdiv(i, i)), imaxdiv_t>::value), "");    static_assert((std::is_same<decltype(strtoimax("", (char**)0, 0)), intmax_t>::value), "");    static_assert((std::is_same<decltype(strtoumax("", (char**)0, 0)), uintmax_t>::value), "");    static_assert((std::is_same<decltype(wcstoimax(L"", (wchar_t**)0, 0)), intmax_t>::value), "");    static_assert((std::is_same<decltype(wcstoumax(L"", (wchar_t**)0, 0)), uintmax_t>::value), "");}

static uintmax_thf_probe_volume_getenv_uintmax (const char *name){  char *str;  g_return_val_if_fail(name != NULL, 0);  str = getenv(name);  return str ? strtoumax(str, NULL, 10) : 0;}

/** * Convert a `char*` to `a size_t` *  * @param   str  The `char*` * @return       The `size_t` */static size_t parse_size(const char* str){  char buf[3 * sizeof(size_t) + 2];  size_t rc;    rc = (size_t)strtoumax(str, NULL, 10);  if (sprintf(buf, "%zu", rc), strcmp(buf, str))    return 0;    return rc;}

ValgrindResult* valgrindXML_evaluate(char *xml_path,int testing_framework) {  char *docname;  xmlDocPtr doc;  xmlChar *xpath = (xmlChar*) "//errorcounts/pair/count";  xmlNodeSetPtr nodeset;  xmlXPathObjectPtr result;  int i;  docname = xml_path;  doc = getdoc(docname);  result = getnodeset (doc, xpath);    ValgrindResult *valgrindResult=NULL;  //Get all the errors first  if (result) {    nodeset = result->nodesetval;    if(nodeset->nodeNr==0){      //NO valgrind errors for this mutant      return NULL;    }    valgrindResult= malloc(sizeof(ValgrindResult));    //Initialization of valgrindResult    valgrindResult->valgrind_error_count=0;    valgrindResult->unique_valgrind_error_count=0;        //Capturing results in valgrindResult    valgrindResult->unique_valgrind_error_count=nodeset->nodeNr;    valgrindResult->valgrindErrors = malloc(nodeset->nodeNr*sizeof(ValgrindError));        for (i=0; i < nodeset->nodeNr; i++) {      //Get <count></count>      xmlNodePtr countNode = nodeset->nodeTab[i];      //Get <unique></unique>      xmlNodePtr uniqueNode = xmlNextElementSibling(countNode);            //Values for both of the nodes      xmlChar *count_value = xmlNodeListGetString(doc, countNode->xmlChildrenNode, 1);      xmlChar *unique_value = xmlNodeListGetString(doc, uniqueNode->xmlChildrenNode, 1);            int error_count = (int)strtoumax((char*)count_value, NULL, 10);      valgrindResult->valgrind_error_count+=error_count;            //For each unique value, get all its error nodes      evaluate_error_nodes(&valgrindResult->valgrindErrors[i],doc,error_count,unique_value,testing_framework);            xmlFree(count_value);      xmlFree(unique_value);    }    xmlXPathFreeObject (result);  }  xmlFreeDoc(doc);  xmlCleanupParser();    return valgrindResult;}

voidcmd_parse_add(int argc, char **argv){	int opt;	while ((opt = getopt(argc, argv, "hp:l:n:k:")) != -1) {		switch (opt) {		case 'h':			cmd_usage_add();			exit(EXIT_FAILURE);		case 'p':			cmd_profile_name = strdup(optarg);			break;		case 'l':			cmd_character_count = strtoumax(optarg, NULL, 10);			break;		case 'n':			cmd_password_count = strtoumax(optarg, NULL, 10);			break;		case 'k':			cmd_gpg_key_id = strdup(optarg);			break;		default:			exit(EXIT_FAILURE);			break;		}	}	argc -= optind;	argv += optind;	if (argc > 0) {		char *s = join_list(' ', argc, argv);		cmd_add_prefix = mbs_duplicate_as_wcs(s);		if (cmd_add_prefix == NULL) {			err(EXIT_FAILURE, "unable to read the prefix (wrong "					"locale?)");		}		xfree(s);	}}

static bool next_field_uintmax(char** current, uintmax_t* result){	char* id_str = next_field(current);	if ( !id_str )		return false;	char* id_endptr;	uintmax_t id_umax = strtoumax(id_str, &id_endptr, 10);	if ( *id_endptr )		return false;	*result = id_umax;	return true;}

static bool _strtoumax(const char *str, int base, uintmax_t *out) {	char *endptr = NULL;	errno = 0;	uintmax_t ret = strtoumax(str, &endptr, base);	if (errno != 0) return false;	if (*endptr != '/0') {		errno = EINVAL;		return false;	}	*out = ret;	return true;}

int main(){    test<int8_t >();    test<int16_t>();    test<int32_t>();    test<int64_t>();    test<uint8_t >();    test<uint16_t>();    test<uint32_t>();    test<uint64_t>();    test<int_least8_t >();    test<int_least16_t>();    test<int_least32_t>();    test<int_least64_t>();    test<uint_least8_t >();    test<uint_least16_t>();    test<uint_least32_t>();    test<uint_least64_t>();    test<int_fast8_t >();    test<int_fast16_t>();    test<int_fast32_t>();    test<int_fast64_t>();    test<uint_fast8_t >();    test<uint_fast16_t>();    test<uint_fast32_t>();    test<uint_fast64_t>();    test<intptr_t >();    test<uintptr_t>();    test<intmax_t >();    test<uintmax_t>();    {    imaxdiv_t  i1 = {};    ((void)i1); // Prevent unused warning    }    intmax_t i = 0;    ((void)i); // Prevent unused warning    static_assert((std::is_same<decltype(imaxabs(i)), intmax_t>::value), "");    static_assert((std::is_same<decltype(imaxdiv(i, i)), imaxdiv_t>::value), "");    static_assert((std::is_same<decltype(strtoimax("", (char**)0, 0)), intmax_t>::value), "");    static_assert((std::is_same<decltype(strtoumax("", (char**)0, 0)), uintmax_t>::value), "");    static_assert((std::is_same<decltype(wcstoimax(L"", (wchar_t**)0, 0)), intmax_t>::value), "");    static_assert((std::is_same<decltype(wcstoumax(L"", (wchar_t**)0, 0)), uintmax_t>::value), "");}

static uintmax_t read_number(void){	uintmax_t number;	errno = 0;	number = strtoumax(optarg, NULL, 10);	if ((number == 0 || number == UINTMAX_MAX) && errno != 0) {		perror("strtoumax");		exit(EXIT_FAILURE);	}	return number;}

static voidassign_time_option (char **sval, time_t *tval, const char *input){  uintmax_t u;  char *p;  time_t t = u = strtoumax (input, &p, 10);  if (t != u || *p || errno == ERANGE)    ERROR ((0, 0, _("Time stamp is out of allowed range")));  else    {      *tval = t;      assign_string (sval, input);    }}

int main(int argc, char **argv){	estats_error* err = NULL;	struct estats_nl_client* cl = NULL;	estats_val_data* data = NULL;	int cid, i, j; 	int opt, option;	char varname[24];	char *endptr, *str;	uintmax_t val;	if (argc < 4) {                usage();                exit(EXIT_FAILURE);        }	        while ((opt = getopt(argc, argv, "h")) != -1) {                switch (opt) {		case 'h':                        usage();                        exit(EXIT_SUCCESS);                        break;                default:                        exit(EXIT_FAILURE);                        break;                }        }	cid = atoi(argv[1]);	strncpy(varname, argv[2], 24);	str = argv[3];	val = strtoumax(str, &endptr, 10);	Chk(estats_nl_client_init(&cl));	Chk(estats_write_var(varname, (uint32_t)val, cid, cl)); Cleanup:	estats_nl_client_destroy(&cl);	if (err != NULL) {		PRINT_AND_FREE(err);		return EXIT_FAILURE;	}	return EXIT_SUCCESS;}

static int parse_port_option(const char *arg){	assert(arg != NULL);	errno = 0;	uintmax_t num = strtoumax(arg, NULL, 10);	if (errno != 0) {		mushroom_log_fatal(strerror(errno));	}	if (num <= 0) {		mushroom_log_fatal("invalid port number: %s", arg);	}	return (int)num;}

static voidmd_prthumanval(char *length){	char buf[6];	uintmax_t bytes;	char *endptr;	errno = 0;	bytes = strtoumax(length, &endptr, 10);	if (errno != 0 || *endptr != '/0' || bytes > INT64_MAX)		return;	humanize_number(buf, sizeof(buf), (int64_t)bytes, "",	    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);	(void)printf("%6s", buf);}

/* * parse_config_integer -- (internal) parse integer value */static inline uintmax_tparse_config_integer(const char *value, uintmax_t max_value){	char *endptr;	uintmax_t v = strtoumax(value, &endptr, 10);	if (endptr != value + strlen(value))		errno = EINVAL;	else if (v > max_value)		errno = ERANGE;	if (errno != 0)		return max_value;	return v;}

static intl_filter_accept(lua_State *L){	uint64_t	id;	const char	*s_id;	if (lua_gettop(L) != 1)		return (0);	s_id = luaL_checklstring(L, 1, NULL);	id = strtoumax(s_id, (char **)NULL, 10);	filter_api_accept(id);	return (0);}

static int ask_number(struct fdisk_context *cxt,		      struct fdisk_ask *ask,		      char *buf, size_t bufsz){	char prompt[128] = { '/0' };	const char *q = fdisk_ask_get_query(ask);	const char *range = fdisk_ask_number_get_range(ask);	uint64_t dflt = fdisk_ask_number_get_default(ask),		 low = fdisk_ask_number_get_low(ask),		 high = fdisk_ask_number_get_high(ask);	assert(q);	DBG(ASK, dbgprint("asking for number ['%s', <%jd,%jd>, default=%jd, range: %s]",				q, low, high, dflt, range));	if (range && dflt >= low && dflt <= high)		snprintf(prompt, sizeof(prompt), _("%s (%s, default %jd): "), q, range, dflt);	else if (dflt >= low && dflt <= high)		snprintf(prompt, sizeof(prompt), _("%s (%jd-%jd, default %jd): "), q, low, high, dflt);	else		snprintf(prompt, sizeof(prompt), _("%s (%jd-%jd): "), q, low, high);	do {		int rc = get_user_reply(cxt, prompt, buf, bufsz);		if (rc)			return rc;		if (!*buf && dflt >= low && dflt <= high)			return fdisk_ask_number_set_result(ask, dflt);		else if (isdigit_string(buf)) {			char *end;			uint64_t num;			errno = 0;			num = strtoumax(buf, &end, 10);			if (errno || buf == end || (end && *end))				continue;			if (num >= low && num <= high)				return fdisk_ask_number_set_result(ask, num);			printf(_("Value out of range./n"));		}	} while (1);	return -1;}

static ssize_tvbf_fetch_number(const char *nbr, int radix){	uintmax_t cll;	ssize_t cl;	char *q;	if (*nbr == '/0')		return (-1);	cll = strtoumax(nbr, &q, radix);	if (q == NULL || *q != '/0')		return (-1);	cl = (ssize_t)cll;	if((uintmax_t)cl != cll) /* Protect against bogusly large values */		return (-1);	return (cl);}

/* * Convert an expression of the following forms to a uintmax_t. * 	1) A positive decimal number. *	2) A positive decimal number followed by a 'b' or 'B' (mult by 512). *	3) A positive decimal number followed by a 'k' or 'K' (mult by 1 << 10). *	4) A positive decimal number followed by a 'm' or 'M' (mult by 1 << 20). *	5) A positive decimal number followed by a 'g' or 'G' (mult by 1 << 30). *	6) A positive decimal number followed by a 't' or 'T' (mult by 1 << 40). *	7) A positive decimal number followed by a 'p' or 'P' (mult by 1 << 50). *	8) A positive decimal number followed by a 'w' or 'W' (mult by sizeof int). *	9) Two or more positive decimal numbers (with/without [BbKkMmGgWw]) *	   separated by 'x' or 'X' (also '*' for backwards compatibility), *	   specifying the product of the indicated values. */static uintmax_tget_num(const char *val){	uintmax_t num, mult, prevnum;	char *expr;	errno = 0;	num = strtoumax(val, &expr, 0);	if (expr == val)			/* No valid digits. */		errx(1, "%s: invalid numeric value", oper);	if (errno != 0)		err(1, "%s", oper);	mult = postfix_to_mult(*expr);	if (mult != 0) {		prevnum = num;		num *= mult;		/* Check for overflow. */		if (num / mult != prevnum)			goto erange;		expr++;	}	switch (*expr) {		case '/0':			break;		case '*':			/* Backward compatible. */		case 'X':		case 'x':			mult = get_num(expr + 1);			prevnum = num;			num *= mult;			if (num / mult == prevnum)				break;erange:			errx(1, "%s: %s", oper, strerror(ERANGE));		default:			errx(1, "%s: illegal numeric value", oper);	}	return (num);}

static intparse_size(struct sun_disklabel *sl, int part, char *size){	uintmax_t nsectors;	uintmax_t total;	uintmax_t n;	char *p;	int i;	nsectors = 0;	n = strtoumax(size, &p, 10);	if (*p != '/0') {		if (strcmp(size, "*") == 0) {			total = sl->sl_ncylinders * sl->sl_ntracks *			    sl->sl_nsectors;			for (i = 0; i < part; i++) {				if (i == 2)					continue;				nsectors += sl->sl_part[i].sdkp_nsectors;			}			n = total - nsectors;		} else if (p[1] == '/0' && (p[0] == 'C' || p[0] == 'c')) {			n = n * sl->sl_ntracks * sl->sl_nsectors;		} else if (p[1] == '/0' && (p[0] == 'K' || p[0] == 'k')) {			n = roundup((n * 1024) / 512,			    sl->sl_ntracks * sl->sl_nsectors);		} else if (p[1] == '/0' && (p[0] == 'M' || p[0] == 'm')) {			n = roundup((n * 1024 * 1024) / 512,			    sl->sl_ntracks * sl->sl_nsectors);		} else if (p[1] == '/0' && (p[0] == 'S' || p[0] == 's')) {			/* size in sectors, no action neded */		} else if (p[1] == '/0' && (p[0] == 'G' || p[0] == 'g')) {			n = roundup((n * 1024 * 1024 * 1024) / 512,			    sl->sl_ntracks * sl->sl_nsectors);		} else			return (-1);	} else if (cflag) {		n = n * sl->sl_ntracks * sl->sl_nsectors;	}	sl->sl_part[part].sdkp_nsectors = n;	return (0);}

/** * /brief Parse string containing time size (1m, 1h, etc). * * /param str String to parse. * * /retval size on success. * /retval 0 on failure. */uint64_t SCParseTimeSizeString (const char *str){    uint64_t size = 0;    uint64_t modifier = 1;    char last = str[strlen(str)-1];    switch (last)    {        case '0' ... '9':            break;        /* seconds */        case 's':            break;        /* minutes */        case 'm':            modifier = 60;            break;        /* hours */        case 'h':            modifier = 60 * 60;            break;        /* days */        case 'd':            modifier = 60 * 60 * 24;            break;        /* weeks */        case 'w':            modifier = 60 * 60 * 24 * 7;            break;        /* invalid */        default:            return 0;    }    errno = 0;    size = strtoumax(str, NULL, 10);    if (errno) {        return 0;    }    return (size * modifier);}

/* Parse a uintmax_t, put it into *result; return 0 on failure, else 1. */int opt_umax(const char *value, uintmax_t *result){    int oerrno = errno;    uintmax_t m;    char *endp;    m = strtoumax(value, &endp, 0);    if (*endp            || endp == value            || (m == UINTMAX_MAX && errno == ERANGE)            || (m == 0 && errno != 0)) {        BIO_printf(bio_err, "%s: Can't parse /"%s/" as a number/n",                   prog, value);        errno = oerrno;        return 0;    }    *result = m;    errno = oerrno;    return 1;}

intmax_t strtoimax(const char *s1, char **p, int base){	const unsigned char *s = (const void *)s1;	int sign = 0;	uintmax_t x;	/* Initial whitespace */	for (; isspace(*s); s++);	/* Optional sign */	if (*s == '-') sign = *s++;	else if (*s == '+') s++;	x = strtoumax((const void *)s, p, base);	if (x > INTMAX_MAX) {		if (!sign || -x != INTMAX_MIN)			errno = ERANGE;		return sign ? INTMAX_MIN : INTMAX_MAX;	}	return sign ? -x : x;}

static uintmax_tgetuintmax(void){	uintmax_t val = 0;	char *cp, *ep;	cp = *gargv;	if (cp == NULL)		goto out;	gargv++;	val = (unsigned char) cp[1];	if (*cp == '/"' || *cp == '/'')		goto out;	errno = 0;	val = strtoumax(cp, &ep, 0);	check_conversion(cp, ep);out:	return val;}

/*! /brief SVSHOST command handler * * /param source_p Pointer to allocated Client struct from which the message *                 originally comes from.  This can be a local or remote client. * /param parc     Integer holding the number of supplied arguments. * /param parv     Argument vector where parv[0] .. parv[parc-1] are non-NULL *                 pointers. * /note Valid arguments for this command are: *      - parv[0] = command *      - parv[1] = nickname *      - parv[2] = TS *      - parv[3] = host name */static intms_svshost(struct Client *source_p, int parc, char *parv[]){  if (!HasFlag(source_p, FLAGS_SERVICE))    return 0;  struct Client *target_p;  if ((target_p = find_person(source_p, parv[1])) == NULL)    return 0;  uintmax_t ts = strtoumax(parv[2], NULL, 10);  if (ts && (ts != target_p->tsinfo))    return 0;  if (valid_hostname(parv[3]) == true)    user_set_hostmask(target_p, parv[3]);  sendto_server(source_p, 0, 0, ":%s SVSHOST %s %ju %s",                source_p->id,                target_p->id, target_p->tsinfo, parv[3]);  return 0;}

static int apply_delta(int argc, const char **argv){	struct line_buffer preimage = LINE_BUFFER_INIT;	struct line_buffer delta = LINE_BUFFER_INIT;	struct sliding_view preimage_view = SLIDING_VIEW_INIT(&preimage, -1);	if (argc != 5)		usage(test_svnfe_usage);	if (buffer_init(&preimage, argv[2]))		die_errno("cannot open preimage");	if (buffer_init(&delta, argv[3]))		die_errno("cannot open delta");	if (svndiff0_apply(&delta, (off_t) strtoumax(argv[4], NULL, 0),					&preimage_view, stdout))		return 1;	if (buffer_deinit(&preimage))		die_errno("cannot close preimage");	if (buffer_deinit(&delta))		die_errno("cannot close delta");	strbuf_release(&preimage_view.buf);	return 0;}

static intl_filter_reject(lua_State *L){	uint64_t	id;	const char	*s_id;	uint32_t	action;	if (lua_gettop(L) != 2)		return (0);	s_id = luaL_checklstring(L, 1, NULL);	id = strtoumax(s_id, (char **)NULL, 10);	action = luaL_checkinteger(L, 2);	switch (action) {	case FILTER_FAIL:	case FILTER_CLOSE:		filter_api_reject(id, action);		break;	}	return (0);}

static int parse_cat_response_line(const char *header, off_t *len){	uintmax_t n;	const char *type;	const char *end;	if (ends_with(header, " missing"))		return error("cat-blob reports missing blob: %s", header);	type = strstr(header, " blob ");	if (!type)		return error("cat-blob header has wrong object type: %s", header);	n = strtoumax(type + strlen(" blob "), (char **) &end, 10);	if (end == type + strlen(" blob "))		return error("cat-blob header does not contain length: %s", header);	if (memchr(type + strlen(" blob "), '-', end - type - strlen(" blob ")))		return error("cat-blob header contains negative length: %s", header);	if (n == UINTMAX_MAX || n > maximum_signed_value_of_type(off_t))		return error("blob too large for current definition of off_t");	*len = n;	if (*end)		return error("cat-blob header contains garbage after length: %s", header);	return 0;}