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

int CAimProto::aim_set_avatar_hash(HANDLE hServerConn, unsigned short &seqno, char flags, unsigned short bart_type, unsigned short &id, char size, const char* hash){    unsigned short offset = 0;    char bart_type_txt[8];    ultoa(bart_type, bart_type_txt, 10);    unsigned short bart_type_len = (unsigned short)mir_strlen(bart_type_txt);    unsigned short req = 0x09;    if (id == 0) {        id = get_random();        req = 0x08;    }    char* buf = (char*)alloca(SNAC_SIZE + TLV_HEADER_SIZE * 2 + 20 + size + bart_type_len);    aim_writesnac(0x13, req, offset, buf, get_random());               // SSI Edit/Add    aim_writeshort(bart_type_len, offset, buf);                       // name length    aim_writegeneric(bart_type_len, bart_type_txt, offset, buf);       // name    aim_writeshort(0, offset, buf);                                   // group id    aim_writeshort(id, offset, buf);                                  // buddy id    aim_writeshort(0x14, offset, buf);                                // buddy type: Buddy Icon    aim_writeshort(2 + size + TLV_HEADER_SIZE, offset, buf);              // length of extra data    char* buf2 = (char*)alloca(2 + size);    buf2[0] = flags;    buf2[1] = (char)size;    memcpy(&buf2[2], hash, size);    aim_writetlv(0xd5, 2 + size, buf2, offset, buf);                  // BART    return aim_sendflap(hServerConn, 0x02, offset, buf, seqno);}

String::String(unsigned long value, unsigned char base){	init();	char buf[33];	ultoa(value, buf, base);	*this = buf;}

int mmc_std_inquiry( SIM_HBA *hba, CCB_SCSIIO *ccb ){	SIM_MMC_EXT		*ext;	SCSI_INQUIRY	*iptr;	char			buf[8];	ext		= (SIM_MMC_EXT *)hba->ext;	iptr	= (SCSI_INQUIRY *)ccb->cam_data.cam_data_ptr;	memset(iptr, 0, sizeof(*iptr));	iptr->peripheral	= D_DIR_ACC;	iptr->rmb			= ext->normval ? CAM_FALSE : CAM_TRUE;	iptr->version		= INQ_VER_SPC3;			// SPC-3	iptr->adlen			= 32;	if (ext->version < MMC_VERSION_1) {		/* Vendor ID */		strcpy((char *)&iptr->vend_id[0], "SD:");		ultoa(ext->cid.sd_cid.mid, buf, 10);		iptr->vend_id[3] = buf[0];		iptr->vend_id[4] = buf[1];		iptr->vend_id[5] = buf[2];		/* Product ID */		strcpy((char *)&iptr->prod_id[0], (char *)ext->cid.sd_cid.pnm);		/* Product revision level, BCD code */		iptr->prod_rev[0] = (ext->cid.sd_cid.prv >> 4) + '0';		iptr->prod_rev[1] = '.';		iptr->prod_rev[2] = (ext->cid.sd_cid.prv & 0x0F) + '0';	} else {

Bool Header :: _GetMerkmalsKode (ulong &MK, char *pText) {#if _MSC_VER >= 1100	HPROJECT hPr = DEX_GetDataSourceHandle();	HeaderEntryX HD (pText,hPr);#else	HeaderEntryX HD (pText);#endif	if (HD.Status () != HE_INVALID)	{		MK = HD.EntryLong ();// KK000608 -----------------------------------#if _MSC_VER >= 1100		long lMKode = MK;		MK = DEX_MapMCodeToHandle(hPr,lMKode);// --------------------------------------------#endif		return True;	}		//  sonst neuen Eintrag erzeugen und speichern	char Buffer [20] = "";	ultoa (MK, Buffer, DEX_GetMkBase ());	HD.SetEntryText (Buffer);	if (HD.WriteBack () != EC_OKAY)  // Wert speichern		return False;	return True;}

static void syspgnumadfun( symvar *e ) // pagenumber.{    e = e;    ultoa( page, syspgnumadstr, 10 );    strcat( syspgnumadstr, "." );    return;};

// unsigned long to stringvoid StrPP::ultos(const unsigned long n){  char num[15];  ultoa(n, num, 10);  SetStr(num);}

///////////////////////////////////////////////////////////////////////////////	US_PrintUnsigned() - Prints an unsigned long/////////////////////////////////////////////////////////////////////////////voidUS_PrintUnsigned(longword n){	char	buffer[32];	US_Print(ultoa(n,buffer,10));}

void loop()                     // run over and over again{       ultoa( encoder0Pos, msg1, 10);  //ultoa ( second, msg1, 10);  digitalWrite(12, 0); //delay(1);  lcd.print( msg1);  digitalWrite(12, 1);   delay(100);/*  if (oldSecond != second) {    Serial.print(second);    Serial.print(". ->");    Serial.print(millis() - starttime);    Serial.println(".");    delay(100);    oldSecond = second;  }*/}

byte ESP8266_Simple::startHttpServer(unsigned port, unsigned long (* requestHandler)(char *buffer, int bufferLength), unsigned int maxBufferSize){  char cmdBuffer[64];  byte responseCode;    this->httpServerRequestHandler = requestHandler;  this->httpServerMaxBufferSize = maxBufferSize;    // Enter MUX mode  responseCode = this->sendCommand(F("AT+CIPMUX=1"));  if(responseCode != ESP8266_OK) return responseCode;    // Set Server Timeout  memset(cmdBuffer,0,sizeof(cmdBuffer));  strcpy_P(cmdBuffer, PSTR("AT+CIPSTO=,"));  ultoa(this->generalCommandTimeoutMicroseconds/1000/1000, cmdBuffer+strlen(cmdBuffer), 10);      this->sendCommand(cmdBuffer);    // Start Server  memset(cmdBuffer,0,sizeof(cmdBuffer));  strcpy_P(cmdBuffer, PSTR("AT+CIPSERVER=1,"));  itoa(port, cmdBuffer+strlen(cmdBuffer), 10);      responseCode = this->sendCommand(cmdBuffer);  if(responseCode != ESP8266_OK) return responseCode;      return ESP8266_OK;}

/* * Convert given signed long integer (@num) to ascii using * desired radix. Return the number of ascii chars printed. * @size: output buffer size */static int ltoa(signed long num, char *buf, int size, int radix){	printk_assert(radix > 2 && radix <= PRINTK_MAX_RADIX);	if (num < 0) {		/* Make room for the '-' */		printk_assert(size >= 2);		num *= -1;		buf[0] = '-';		return ultoa(num, buf+1, size-1, radix) + 1;	}	return ultoa(num, buf, size, radix);}

//---------------------------------------------------------------------------UINT GetTempFileName(char *PathName,char *Prefix,UINT Unique,char *TempFileName){  EasyStr Ret;  WORD Num=WORD(Unique ? WORD(Unique):WORD(rand() & 0xffff));  for(;;){    Ret=PathName;    Ret+=SLASH;    Ret+=Prefix;    Ret.SetLength(MAX_PATH+4);    char *StartOfNum=Ret.Right()+1;    ultoa(Num,StartOfNum,16);    strupr(StartOfNum);    Ret+=".TMP";    if (Ret.Length()<MAX_PATH){      if (Unique==0){        if (access(Ret,0)==0){ //File exists          Num++;        }else{          strcpy(TempFileName,Ret);          fclose(fopen(TempFileName,"wb"));          return Num;        }      }else{        strcpy(TempFileName,Ret);        return Num;      }    }else{      return 0;    }  }}

String & String::append(unsigned long num){	char buf[11];	ultoa(num, buf, 10);	append(buf, strlen(buf));	return *this;}

String::String(unsigned long value, unsigned char base){	init();	char buf[1 + 8 * sizeof(unsigned long)];	ultoa(value, buf, base);	*this = buf;}

/* Adds the elfcorehdr= command line parameter to command line. */static int cmdline_add_elfcorehdr(char *cmdline, unsigned long addr){    int cmdlen, len, align = 1024;    char str[30], *ptr;    /* Passing in elfcorehdr=xxxK format. Saves space required in cmdline.     * Ensure 1K alignment*/    if (addr%align)        return -1;    addr = addr/align;    ptr = str;    strcpy(str, " elfcorehdr=");    ptr += strlen(str);    ultoa(addr, ptr);    strcat(str, "K");    len = strlen(str);    cmdlen = strlen(cmdline) + len;    if (cmdlen > (COMMAND_LINE_SIZE - 1))        die("Command line overflow/n");    strcat(cmdline, str);#if 0    printf("Command line after adding elfcorehdr/n");    printf("%s/n", cmdline);#endif    return 0;}

void DumpType(                  // DUMP TYPE ENTRY    TYPE tp )                   // - type pointer{    char *id;                   // - id for symbol    if( tp == NULL ) {        printf( "NULL type/n" );        return;    }    if( tp->id >= TYP_MAX ) {        ultoa( tp->id, unknown_type + sizeof( unknown_type ) - 2, 16 );        id = unknown_type;    } else {        id = id_names[ tp->id ];    }    printf( "TYPE"          F_BADDR            " next"         F_PTR            " id="          F_STRING            " flag"         F_HEX_1            " of"           F_PTR            " u1"           F_PTR            " u2"           F_PTR            F_EOL          , tp          , tp->next          , id          , tp->flag          , tp->of          , tp->u.f.args          , tp->u.f.pragma          );}

voidxpcc::IOStream::writeInteger(uint32_t value){#if defined(XPCC__CPU_AVR)	char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '/0'		// Uses the optimized non standard function 'ultoa()' which is	// not always available.	this->device->write(ultoa(value, buffer, 10));#else	char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '/0'		// ptr points to the end of the string, it will be filled backwards	char *ptr = buffer + ArithmeticTraits<uint32_t>::decimalDigits;	*ptr = '/0';	// calculate the string backwards	do{		uint32_t quot = value / 10;		uint8_t rem = value - quot*10;		*(--ptr) = static_cast<char>(rem) + '0';		value = quot;	}while (value != 0);	// write string	this->device->write(ptr);#endif}

char* MyMessage::getString(char *buffer) const {	uint8_t payloadType = miGetPayloadType();	if (payloadType == P_STRING) {		strncpy(buffer, data, miGetLength());		buffer[miGetLength()] = 0;		return buffer;	} else if (buffer != NULL) {		if (payloadType == P_BYTE) {			itoa(bValue, buffer, 10);		} else if (payloadType == P_INT16) {			itoa(iValue, buffer, 10);		} else if (payloadType == P_UINT16) {			utoa(uiValue, buffer, 10);		} else if (payloadType == P_LONG32) {			ltoa(lValue, buffer, 10);		} else if (payloadType == P_ULONG32) {			ultoa(ulValue, buffer, 10);		} else if (payloadType == P_FLOAT32) {			dtostrf(fValue,2,fPrecision,buffer);		} else if (payloadType == P_CUSTOM) {			return getCustomString(buffer);		}		return buffer;	} else {		return NULL;	}}

NAME NameDummy( void )/********************/{    name_dummy_index_t ni;    unsigned xhash;    unsigned bucket;    unsigned len;    idname **head;    char buff[ 1 + 1 + sizeof( ni ) * 3 + 1 ];    ExtraRptIncrementCtr( ctr_dummy_names );    ni = nameDummyIndex++;    xhash = ni % NAME_TABLE_HASH;    bucket = xhash;    buff[0] = NAME_OPERATOR_OR_DUMMY_PREFIX1;    buff[1] = NAME_DUMMY_PREFIX2;    // the contents of the name don't have to be different just the address    // but for debugging it is handy to have unique contents#ifndef NDEBUG    ultoa( ni, &buff[2], 10 );    len = strlen( buff );#else    buff[2] = '0';    buff[3] = '/0';    len = 3;#endif    head = &(hashTable[ bucket ]);    return( nameAdd( head, bucket, xhash, buff, len ) );}

static int add_cmdline_param(char *cmdline, uint64_t addr, char *cmdstr,				char *byte){	int cmdlen, len, align = 1024;	char str[COMMAND_LINE_SIZE], *ptr;	/* Passing in =xxxK / =xxxM format. Saves space required in cmdline.*/	switch (byte[0]) {		case 'K':			if (addr%align)				return -1;			addr = addr/align;			break;		case 'M':			addr = addr/(align *align);			break;	}	ptr = str;	strcpy(str, cmdstr);	ptr += strlen(str);	ultoa(addr, ptr);	strcat(str, byte);	len = strlen(str);	cmdlen = strlen(cmdline) + len;	if (cmdlen > (COMMAND_LINE_SIZE - 1))		die("Command line overflow/n");	strcat(cmdline, str);#if DEBUG	fprintf(stderr, "Command line after adding elfcorehdr: %s/n", cmdline);#endif	return 0;}

unsigned char String::concat(unsigned long num){    char buf[11];    ultoa(num, buf, 10);    return concat( buf, strlen(buf) );}

uint8_t* f2str(freq_t f, uint8_t *buffer, uint8_t len){    uint8_t i;    uint8_t j;    uint8_t *p;    // Mhz    ultoa(f_MHZ(f), buffer, 10);    i = len - strlen(buffer);    j = 0;    p = buffer + strlen(buffer);    // multiply fractional part to get the rest of required digits    while (j < i) {        if (j & 0b11) {            f = 10 * (f - MHZ_f(f_MHZ(f)));            *p = '0' + f_MHZ(f);        }        else{            if (j == 0) *p = ',';            else *p = '.';        }        ++p;        ++j;    }    // discard ending dot    if (*(p-1) == '.') --p;    *p = '/0';    return buffer;}

void fib(void *n){    unsigned long val;    char str_val[100]={0};    if(n == NULL)    {	print_str("Invalid argument/n");	print_str("Usage: fin n/n");    }    val = strtol(n,NULL,10);    print_str("input n is ");    print_str(n);    print_str("/r/n/0");    print_str("calculating... ");    val = fibonacci(val);    print_str("/r/n/0");    print_str("fib(n) : ");    ultoa(val, str_val, 10);    print_str(str_val);    print_str("/r/n/n/0");    return; }

void    scr_el( void ){    ifcb    *   cb = input_cbs->if_cb;    char        linestr[MAX_L_AS_STR];    scan_err = false;    cb->if_flags[cb->if_level].iflast = false;    cb->if_flags[cb->if_level].ifcwte = false;    if( !(cb->if_flags[cb->if_level].iftrue          || cb->if_flags[cb->if_level].iffalse)        || cb->if_flags[cb->if_level].ifthen        || cb->if_flags[cb->if_level].ifelse        || cb->if_flags[cb->if_level].ifdo ) {        scan_err = true;        g_err( err_if_else );        if( input_cbs->fmflags & II_macro ) {            ultoa( input_cbs->s.m->lineno, linestr, 10 );            g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name );        } else {            ultoa( input_cbs->s.f->lineno, linestr, 10 );            g_info( inf_file_line, linestr, input_cbs->s.f->filename );        }        show_ifcb( "else", cb );        show_include_stack();        err_count++;        return;    }    cb->if_flags[cb->if_level].ifelse = true;    ProcFlags.keep_ifstate = true;    if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) {        show_ifcb( "else", cb );    }    garginit();                         // find end of control word    while( *scan_start == ' ' ) {        scan_start++;    }    if( *scan_start ) {                 // rest of line is not empty split        split_input( buff2, scan_start, false );// and process next    }    scan_restart = scan_stop + 1;    return;}

/* * generate and transmit pathname block consisting of *  pathname (null terminated), *  file length, mode time and file mode in octal *  as provided by the Unix fstat call. *  N.B.: modifies the passed name, may extend it! */int wctxpn(const char *name){  char *p, *q;//DSERIAL.println("/nwctxpn");  strcpy(txbuf,name);  p = q = txbuf + strlen(txbuf)+1;  //Pete (El Supremo) fix bug - was 1024, should be TXBSIZE??  while (q < (txbuf + TXBSIZE))    *q++ = 0;//  if (!Ascii && (in!=stdin) && *name && fstat(fileno(in), &f)!= -1)  if (!Ascii)    // I will have to figure out how to convert the uSD date/time format to a UNIX epoch//    sprintf(p, "%lu %lo %o 0 %d %ld", fout.fileSize(), 0L,0600, Filesleft, Totalleft);// Avoid sprintf to save memory for small boards.  This sketch doesn't know what time it is anyway    ultoa(fout.fileSize(), p, 10);    strcat_P(p, PSTR(" 0 0 0 "));    q = p + strlen(p);    ultoa(Filesleft, q, 10);    strcat_P(q, PSTR(" "));    q = q + strlen(q);    ultoa(Totalleft, q, 10);  Totalleft -= fout.fileSize();//DSERIAL.print(F("wctxpn sf = "));//DSERIAL.print(sf);//DSERIAL.print(F("  length = "));//DSERIAL.println(Totalleft);  if (--Filesleft <= 0)    Totalleft = 0;  if (Totalleft < 0)    Totalleft = 0;  /* force 1k blocks if name won't fit in 128 byte block */  //Pete (El Supremo) This can't be right??!  if (txbuf[125])//    blklen=1024;    blklen = TXBSIZE;  else {          /* A little goodie for IMP/KMD */    blklen = 128;    txbuf[127] = (fout.fileSize() + 127) >>7;    txbuf[126] = (fout.fileSize() + 127) >>15;  }  return zsendfile(txbuf, 1+strlen(p)+(p-txbuf));}

/*******************************************************************************************************************************   Read specified metric's value of the Winsen MH-Zxx CO2 sensor via UART, put it to output buffer on success. **   Returns: *     - RESULT_IS_BUFFERED on success*     - DEVICE_ERROR_TIMEOUT if device stop talking******************************************************************************************************************************/int8_t getMHZxxMetricUART(const uint8_t _rxPin, const uint8_t _txPin, uint8_t* _dst, int32_t* _value, const uint8_t _wantsNumber) {  uint8_t len, rc = DEVICE_ERROR_TIMEOUT;  SoftwareSerial swSerial(_rxPin, _txPin);  // Send query only if sensor heated  if (millis() > MH_ZXX_PREHEAT_TIMEOUT) {       swSerial.begin(MH_ZXX_UART_SPEED);     _dst[MH_ZXX_STARTING_BYTE] = 0xFF;                           // Starting byte     _dst[MH_ZXX_SENSOR_NUMBER] = 0x01;                           // Sensor No.     _dst[MH_ZXX_CMD] = MH_ZXX_CMD_GAS_CONCENTRATION;             // Command     _dst[3] = _dst[4] = _dst[5] = _dst[6] = _dst[7] = 0x00;      // Stub bytes     _dst[MH_ZXX_CRC] = 0x79;                                     // Check value     // Flush all device's transmitted data to avoid get excess data in recieve buffer     //serialRXFlush(&swSerial, !UART_SLOW_MODE);     flushStreamRXBuffer(&swSerial, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_SLOW_MODE);     // The serial stream can get out of sync. The response starts with 0xff, try to resync : https://github.com/jehy/arduino-esp8266-mh-z19-serial/blob/master/arduino-esp8266-mhz-19-serial.ino     //  Send command to MH-Zxx     serialSend(&swSerial, _dst, MH_ZXX_PACKET_SIZE, !UART_SLOW_MODE);          //  Recieve from MH-Zxx     //  It actually do not use '/r', '/n', '/0' to terminate string     len = serialRecive(&swSerial, _dst, MH_ZXX_PACKET_SIZE, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_STOP_ON_CHAR, '/r', !UART_SLOW_MODE);          // Connection timeout occurs     if (len < MH_ZXX_PACKET_SIZE) { rc = DEVICE_ERROR_TIMEOUT; goto finish; }          // Wrong answer. buffer[0] must contain 0xFF     if (0xFF != _dst[MH_ZXX_STARTING_BYTE]) { rc = DEVICE_ERROR_WRONG_ANSWER; goto finish; }          // Bad CRC     // CRC calculate for bytes #1..#9 (byte #0 excluded)     if (_dst[MH_ZXX_CRC] != crcMHZxx(_dst)) { rc = DEVICE_ERROR_CHECKSUM; goto finish; }          *_value = 256 * _dst[MH_ZXX_GAS_CONCENTRATION_HIGH_BYTE];     *_value += _dst[MH_ZXX_GAS_CONCENTRATION_LOW_BYTE];  } else {  // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)     // Return 'good concentracion' while sensor heated     *_value = MH_ZXX_PREHEAT_GAS_CONCENTRATION;  } // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)  if (!_wantsNumber) {     ultoa(*_value, (char*) _dst, 10);  }  rc = RESULT_IS_BUFFERED;  finish:  gatherSystemMetrics(); // Measure memory consumption  swSerial.~SoftwareSerial();   return rc;}

String::String( const unsigned long value, const int base ){  char buf[33];     ultoa(value, buf, 10);  getBuffer( _length = strlen(buf) );  if ( _buffer != NULL )    strcpy( _buffer, buf );}